ryugi-artifacts 1.63.0 → 1.65.0

package/dist/cli.cjs

@@ -84,10 +84,10 @@ function normalize(command, result2, options, policy) {
     const keys = [.../* @__PURE__ */ new Set([...options.fields, ...policy.requiredFields ?? []])];
     if (policy.collection && data && typeof data === "object") {
       const record = data;
-      const rows = record[policy.collection];
+      const rows2 = record[policy.collection];
       data = {
         ...record,
-        [policy.collection]: Array.isArray(rows) ? rows.map((row, i) => project(row, keys, `data.${policy.collection}.${i}`, omitted)) : rows
+        [policy.collection]: Array.isArray(rows2) ? rows2.map((row, i) => project(row, keys, `data.${policy.collection}.${i}`, omitted)) : rows2
       };
     } else data = project(data, keys, "data", omitted);
   }
@@ -275,9 +275,9 @@ function wantsHelp(args) {
   const end = args.indexOf("--");
   return (end === -1 ? args : args.slice(0, end)).some((arg) => arg === "--help" || arg === "-h");
 }
-function table(rows) {
-  const width = Math.max(...rows.map(([left]) => left.length)) + 2;
-  return rows.map(
+function table(rows2) {
+  const width = Math.max(...rows2.map(([left]) => left.length)) + 2;
+  return rows2.map(
     ([left, right]) => `  ${left.padEnd(width)}${right.replaceAll("\n", `
   ${" ".repeat(width)}`)}`.trimEnd()
   ).join("\n");
@@ -290,7 +290,7 @@ function optionRows(options) {
 }
 function commandHelp(command) {
   const usage = (command.usage ?? ["[options]"]).map(
-    (line, index) => `${index ? "       " : "Usage: "}${BIN} ${command.name} ${line}`
+    (line2, index) => `${index ? "       " : "Usage: "}${BIN} ${command.name} ${line2}`
   );
   return [
     usage.join("\n"),
@@ -494,19 +494,33 @@ var EffectJournal = class {
     this.entries.push({ operation, target, state: "unknown" });
     return this.entries.length - 1;
   }
-  confirm(id, details) {
-    this.set(id, "confirmed", details);
+  confirm(id2, details) {
+    this.set(id2, "confirmed", details);
   }
-  set(id, state, details) {
-    const entry = this.entries[id];
+  set(id2, state, details) {
+    const entry = this.entries[id2];
     if (!entry) throw new Error("Unknown effect");
-    this.entries[id] = { ...entry, state, ...details === void 0 ? {} : { details } };
+    this.entries[id2] = { ...entry, state, ...details === void 0 ? {} : { details } };
   }
   snapshot() {
     return this.entries.map((entry) => ({ ...entry }));
   }
 };
 
+// src/cli/output/time.ts
+var ISO = /^\d{4}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d+)?)?(?:Z|[+-]\d\d:?\d\d)$/;
+var two = (n) => String(n).padStart(2, "0");
+var isIsoTime = (value3) => typeof value3 === "string" && ISO.test(value3) && !Number.isNaN(Date.parse(value3));
+function formatTime(iso, now = /* @__PURE__ */ new Date()) {
+  const at = new Date(iso);
+  if (Number.isNaN(at.getTime())) return iso;
+  const clock = `${two(at.getHours())}:${two(at.getMinutes())}`;
+  if (at.getFullYear() !== now.getFullYear())
+    return `${at.getFullYear()}-${two(at.getMonth() + 1)}-${two(at.getDate())}`;
+  if (at.getMonth() === now.getMonth() && at.getDate() === now.getDate()) return clock;
+  return `${two(at.getMonth() + 1)}-${two(at.getDate())} ${clock}`;
+}
+
 // src/cli/output/view.ts
 function recoveryActions(error, subject) {
   const details = error.details;
@@ -526,13 +540,57 @@ var fact = (label, binding, required = false) => ({
 });
 
 // src/cli/output/render.ts
-var clean = (text) => text.replaceAll(new RegExp("\\p{Cc}", "gu"), " ");
-function clip(text, size = 160) {
-  const segments = [...new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(text)];
-  return segments.length > size ? `${segments.slice(0, size).map((s) => s.segment).join("")}\u2026` : text;
+var clean = (text2) => text2.replaceAll(new RegExp("\\p{Cc}", "gu"), " ");
+function clip(text2, size = 160) {
+  const segments = [...new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(text2)];
+  return segments.length > size ? `${segments.slice(0, size).map((s) => s.segment).join("")}\u2026` : text2;
+}
+function flatten(value3, nested = false) {
+  if (value3 === null || value3 === void 0) return "";
+  if (Array.isArray(value3)) return value3.map((item) => flatten(item, true)).join(", ");
+  if (typeof value3 === "object") {
+    const text2 = Object.entries(value3).filter(([, item]) => !absent(item)).map(([key, item]) => `${key} ${flatten(item, true)}`).join(nested ? ", " : " \xB7 ");
+    return nested ? `(${text2})` : text2;
+  }
+  return isIsoTime(value3) ? formatTime(value3) : String(value3);
+}
+var scalar = (value3, path18, loose) => {
+  if (value3 !== null && typeof value3 === "object") {
+    if (!loose)
+      throw new Error(`Brief cannot print the object at ${path18}; flatten it in the view.`);
+    return flatten(value3);
+  }
+  return flatten(value3);
+};
+var absent = (value3, fallback) => value3 === void 0 || value3 === null || value3 === "" || value3 === false || fallback !== void 0 && value3 === fallback;
+var EXIT_WORDS = {
+  1: "FAILED",
+  2: "NEEDS YOU",
+  3: "ISSUES",
+  4: "INCOMPLETE",
+  5: "PARTIAL",
+  130: "INTERRUPTED",
+  143: "INTERRUPTED"
+};
+var RECOVERY = {
+  E_ARTIFACT_NOT_FOUND: "check --artifact and --project-dir; artifacts live in <project>/.ryugi/artifacts/<type>/<id>/",
+  E_ARGUMENT_INVALID: "run the command with --help for its options",
+  E_CURSOR_EXPIRED: "run the read again without --cursor or --snapshot",
+  E_CURSOR_MISMATCH: "run the read again without --cursor or --snapshot"
+};
+var statusWord = (status, code) => code ? EXIT_WORDS[code] ?? "FAILED" : clean(status).replaceAll("_", " ").toUpperCase();
+var commandName = (id2) => {
+  const words2 = id2.replaceAll(/[._]/g, " ").trim();
+  return words2 ? words2[0].toUpperCase() + words2.slice(1) : "Command";
+};
+function pageText(page) {
+  const offset = page.offset ?? 0;
+  if (!page.hasMore && offset === 0) return null;
+  const of = page.total === null ? "" : ` of ${page.total}`;
+  if (page.offset === void 0)
+    return `${page.returned}${of} shown${page.total === null && page.hasMore ? " \xB7 more available" : ""}`;
+  return `${page.returned ? `${offset + 1}\u2013${offset + page.returned}` : "none"}${of}`;
 }
-var scalar = (value3) => value3 === null ? "none" : typeof value3 === "object" ? JSON.stringify(value3) : String(value3);
-var scopeText = (page) => `${clean(page.scope)} \xB7 ${page.returned} shown${page.total === null ? "" : ` / ${page.total} matched`}${page.hasMore ? " \xB7 more available" : ""}`;
 var quote = (value3) => /^[\w./:@=+-]+$/.test(value3) ? value3 : `'${value3.replaceAll("'", "'\\''")}'`;
 function actionText(action) {
   return action.kind === "command" ? action.argv.map(quote).join(" ") : action.url;
@@ -540,38 +598,72 @@ function actionText(action) {
 var effectLines = (effects) => effects.map(
   (effect) => `Effect: ${clean(effect.operation)} ${clean(effect.target)} \xB7 ${effect.state}`
 );
-function renderText(view, wire, options, collection, requiredFields = []) {
-  const lines = [
-    `${clean(view.heading)}: ${clean(view.status).toUpperCase()}${view.subject ? ` \xB7 ${clean(view.subject)}` : ""}`
-  ];
+var lastSegment = (path18) => path18.split(".").filter(Boolean).at(-1) ?? path18;
+function renderText(view, wire, options, collection, requiredFields = [], code = 0) {
+  const head = [
+    statusWord(view.status, code),
+    view.subject && clean(view.subject),
+    view.summary && clean(view.summary)
+  ].filter(Boolean);
+  const lines = [head.length ? `${clean(view.heading)}: ${head.join(" \xB7 ")}` : clean(view.heading)];
   const omissions = [...wire.omitted ?? []];
   const selected = (key, required = false) => required || requiredFields.includes(key) || !options.fields || options.fields.includes(key);
-  const value3 = (input, path18) => {
-    const text = clean(scalar(input));
-    const shown = options.detail ? text : clip(text);
-    if (shown !== text) omissions.push({ path: path18, reason: "preview" });
+  const value3 = (input, path18, loose = false) => {
+    const text2 = clean(scalar(input, path18, loose));
+    const shown = options.detail ? text2 : clip(text2);
+    if (shown !== text2) omissions.push({ path: path18, reason: "preview" });
     return shown;
   };
-  const facts = (items) => {
-    for (const item of items)
-      if (collection || selected(item.binding.key, item.required))
-        lines.push(
-          `${clean(item.label)}: ${value3(item.binding.value, `data.${item.binding.key}`)}`
-        );
+  const cell = (label, key, input, path18, positional2, fallback, loose = false) => {
+    if (absent(input, fallback)) return null;
+    const name = clean(label ?? key);
+    if (input === true) return name;
+    const text2 = value3(input, path18, loose);
+    return positional2 ? text2 : `${name} ${text2}`;
+  };
+  const facts = (items, loose = false) => {
+    for (const item of items) {
+      if (!collection && !selected(item.binding.key, item.required)) continue;
+      if (absent(item.binding.value)) continue;
+      const text2 = item.binding.value === true ? "yes" : value3(item.binding.value, `data.${item.binding.key}`, loose);
+      lines.push(`${clean(item.label)}: ${text2}`);
+    }
+  };
+  const metadata = (items, path18) => items.map(
+    (item) => cell(
+      item.label,
+      item.binding.key,
+      item.binding.value,
+      `${path18}.${item.binding.key}`,
+      item.positional
+    )
+  ).filter((text2) => text2 !== null).join(" \xB7 ");
+  const title2 = (text2, summary) => {
+    if (text2) lines.push(summary ? `${clean(text2)} \xB7 ${clean(summary)}` : clean(text2));
+  };
+  const pageLine = (page) => {
+    const text2 = page && pageText(page);
+    if (text2) lines.push(text2);
   };
   facts(view.facts);
   const errorActions = wire.error ? recoveryActions(wire.error) : [];
   if (wire.error) {
     lines.push(`${clean(wire.error.code)}: ${clean(wire.error.message)}`);
-    if (wire.error.httpStatus !== void 0) lines.push(`HTTP: ${wire.error.httpStatus}`);
-    const details = wire.error.details;
-    if (details && typeof details === "object" && !Array.isArray(details)) {
-      for (const [key, detail] of Object.entries(details)) {
+    if (wire.error.httpStatus !== void 0 && wire.error.httpStatus >= 500)
+      lines.push(`HTTP: ${wire.error.httpStatus}`);
+    const hint = RECOVERY[wire.error.code];
+    if (hint) lines.push(`Next: ${hint}`);
+    const details2 = wire.error.details;
+    if (details2 && typeof details2 === "object" && !Array.isArray(details2)) {
+      for (const [key, detail] of Object.entries(details2)) {
         if (!errorActions.some((action) => action.label === key))
-          facts([{ label: key, binding: { key, value: detail }, required: true }]);
+          facts([{ label: key, binding: { key, value: detail }, required: true }], true);
       }
-    } else if (details !== void 0)
-      facts([{ label: "Details", binding: { key: "details", value: details }, required: true }]);
+    } else if (details2 !== void 0)
+      facts(
+        [{ label: "Details", binding: { key: "details", value: details2 }, required: true }],
+        true
+      );
   }
   if (!collection && options.fields && wire.data && typeof wire.data === "object") {
     const bound = /* @__PURE__ */ new Set([
@@ -582,7 +674,8 @@ function renderText(view, wire, options, collection, requiredFields = []) {
     ]);
     const data = wire.data;
     facts(
-      [.../* @__PURE__ */ new Set([...options.fields, ...requiredFields])].filter((key) => !bound.has(key) && Object.hasOwn(data, key)).map((key) => ({ label: key, binding: { key, value: data[key] } }))
+      [.../* @__PURE__ */ new Set([...options.fields, ...requiredFields])].filter((key) => !bound.has(key) && Object.hasOwn(data, key)).map((key) => ({ label: key, binding: { key, value: data[key] } })),
+      true
     );
   }
   for (const section of view.sections) {
@@ -591,59 +684,66 @@ function renderText(view, wire, options, collection, requiredFields = []) {
       continue;
     }
     if (!collection && !selected(section.key)) continue;
-    if (section.page)
-      lines.push(
-        `${clean("title" in section && section.title || section.key)}: ${section.status ? `${clean(section.status)} \xB7 ` : ""}${scopeText(section.page)}`
-      );
+    const named = "title" in section && section.title ? section.title : void 0;
     if (section.kind === "records") {
-      if (section.title && !section.page) lines.push(clean(section.title));
+      title2(named ?? (section.page ? section.key : void 0), section.summary);
       const declared = new Set(section.columns.map((column) => column.key));
-      const extra = section.key === collection ? [.../* @__PURE__ */ new Set([...options.fields ?? [], ...requiredFields])].filter((key) => !declared.has(key)).map((key) => ({ key, label: key })) : [];
-      const columns2 = [...section.columns, ...extra].filter(
+      const extra = section.key === collection ? [.../* @__PURE__ */ new Set([...options.fields ?? [], ...options.fields ? requiredFields : []])].filter((key) => !declared.has(key)).map((key) => ({ key, label: key })) : [];
+      const loose = new Set(extra.map((column) => column.key));
+      const columns = [...section.columns, ...extra].filter(
         (column) => section.key !== collection || selected(column.key, column.required)
       );
-      const rows = section.rows.map(
-        (row, i) => columns2.map(
-          (column) => value3(
-            row[column.key] === void 0 ? "" : row[column.key],
-            `data.${section.key}.${i}.${column.key}`
-          )
-        )
-      );
       if (options.format === "table") {
-        const labels = columns2.map((column) => column.label);
+        const labels = columns.map((column) => column.label ?? column.key);
+        const rows2 = section.rows.map(
+          (row, i) => columns.map(
+            (column) => absent(row[column.key], column.default) ? "" : value3(
+              row[column.key],
+              `data.${section.key}.${i}.${column.key}`,
+              loose.has(column.key)
+            )
+          )
+        );
         const widths = labels.map(
-          (label, i) => Math.max(label.length, ...rows.map((row) => row[i]?.length ?? 0))
+          (label, i) => Math.max(label.length, ...rows2.map((row) => row[i]?.length ?? 0))
         );
         lines.push(
-          ...[labels, ...rows].map(
-            (row) => row.map((cell, i) => cell.padEnd(widths[i] ?? cell.length)).join("  ").trimEnd()
+          ...[labels, ...rows2].map(
+            (row) => row.map((text2, i) => text2.padEnd(widths[i] ?? text2.length)).join("  ").trimEnd()
           )
         );
       } else
-        for (const row of rows)
+        for (const [i, row] of section.rows.entries())
           lines.push(
-            `  ${columns2.flatMap((column, i) => {
-              const cell = row[i];
-              return cell === void 0 || cell === "" ? [] : [`${clean(column.label)}=${cell}`];
-            }).join(" \xB7 ")}`
+            `  ${columns.map(
+              (column) => cell(
+                column.label,
+                column.key,
+                row[column.key],
+                `data.${section.key}.${i}.${column.key}`,
+                column.positional,
+                column.default,
+                loose.has(column.key)
+              )
+            ).filter((text2) => text2 !== null).join(" \xB7 ")}`
           );
-      if (!rows.length && !section.page) lines.push("No records.");
+      if (!section.rows.length && !named && !section.page) lines.push("No records.");
+      pageLine(section.page);
     } else if (section.kind === "messages") {
-      if (section.title && !section.page) lines.push(`${clean(section.title)}:`);
-      const metadata = (items) => items.map((item) => `${clean(item.label)}=${clean(scalar(item.binding.value))}`).join(" \xB7 ");
-      for (const group of section.groups) {
-        lines.push(`  ${metadata(group.facts)}`);
-        for (const message of group.messages) {
-          lines.push(`    ${metadata(message.facts)}`);
+      title2(named, section.summary);
+      for (const [g, group] of section.groups.entries()) {
+        lines.push(`  ${metadata(group.facts, `data.${section.key}.${g}`)}`);
+        for (const [m, message] of group.messages.entries()) {
+          lines.push(`    ${metadata(message.facts, `data.${section.key}.${g}.messages.${m}`)}`);
           lines.push(
             ...message.text.split("\n").map(
-              (line) => `      ${line.replaceAll(new RegExp("\\p{Cc}", "gu"), (char) => char === "	" ? char : "")}`
+              (line2) => `      ${line2.replaceAll(new RegExp("\\p{Cc}", "gu"), (char) => char === "	" ? char : "")}`
             )
           );
         }
       }
-      if (!section.groups.length && !section.page) lines.push("No messages.");
+      if (!section.groups.length && !named && !section.page) lines.push("No messages.");
+      pageLine(section.page);
     } else if (section.kind === "diagnostics") {
       const limit = options.detail ? section.items.length : section.preview ?? 3;
       for (const item of section.items.slice(0, limit))
@@ -657,34 +757,50 @@ function renderText(view, wire, options, collection, requiredFields = []) {
           count: section.items.length - limit
         });
     } else {
-      if (section.title && !section.page) lines.push(`${clean(section.title)}:`);
+      title2(named && `${named}:`, section.summary);
       lines.push(
         ...section.text.trimEnd().split("\n").map(
-          (line) => `  ${line.replaceAll(new RegExp("\\p{Cc}", "gu"), (char) => char === "	" || char === "\n" ? char : "")}`
+          (line2) => `  ${line2.replaceAll(new RegExp("\\p{Cc}", "gu"), (char) => char === "	" || char === "\n" ? char : "")}`
         )
       );
     }
   }
-  if (wire.page) lines.push(`Scope: ${scopeText(wire.page)}`);
-  lines.push(...effectLines(wire.effects ?? []));
+  if (wire.page) pageLine(wire.page);
+  if (code || (wire.effects ?? []).some((effect) => effect.state !== "confirmed"))
+    lines.push(...effectLines(wire.effects ?? []));
   for (const warning of wire.warnings ?? []) lines.push(`Warning: ${clean(warning.message)}`);
-  if (omissions.length)
-    lines.push(
-      `Omitted: ${omissions.map((item) => `${item.count === void 0 ? "" : `${item.count} `}${item.path} (${item.reason})`).join(", ")}`
-    );
-  for (const action of [...view.actions ?? wire.next ?? [], ...errorActions])
-    lines.push(`${clean(action.label ?? "Next")}: ${actionText(action)}`);
+  const actions = [...view.actions ?? wire.next ?? [], ...errorActions];
+  const used = /* @__PURE__ */ new Set();
+  const details = actions.find((action) => action.label === "Details");
+  for (const omission of omissions) {
+    if (omission.count === void 0) continue;
+    const more = `${omission.count} more ${lastSegment(omission.path)}`;
+    if (details && !used.has(details)) {
+      used.add(details);
+      lines.push(`${more} \xB7 Details: ${actionText(details)}`);
+    } else lines.push(more);
+  }
+  if (!details && !options.detail && omissions.some((item) => item.reason === "preview" && item.count === void 0))
+    lines.push("Some values are clipped; add --detail to see them in full.");
+  for (const action of actions)
+    if (!used.has(action))
+      lines.push(
+        `${clean(action.label ?? "Next")}: ${action.reason ? `${clean(action.reason)} \xB7 ` : ""}${actionText(action)}`
+      );
   return `${lines.join("\n")}
 `;
 }
-function renderFailure(wire, options) {
+function renderFailure(wire, options, code = 1) {
   return renderText(
-    { heading: wire.command, status: wire.outcome, facts: [], sections: [] },
+    { heading: commandName(wire.command), status: "", facts: [], sections: [] },
     wire,
     {
       ...options,
       fields: void 0
-    }
+    },
+    void 0,
+    [],
+    code
   );
 }
 
@@ -725,8 +841,8 @@ async function runCommand(definition, input, options, writer, signal) {
     return `${JSON.stringify({ schema: "ryugi.cli/v1", ...value3, seq: seq++, kind })}
 `;
   }
-  function enqueue(channel, text) {
-    queue = queue.then(() => writer.write(channel, text)).catch((err) => {
+  function enqueue(channel, text2) {
+    queue = queue.then(() => writer.write(channel, text2)).catch((err) => {
       queueError = err;
       abort.abort(err);
     });
@@ -736,14 +852,14 @@ async function runCommand(definition, input, options, writer, signal) {
     if (queueError) throw queueError;
   }
   const maxBytes = 8 * 1024 * 1024;
-  async function write(channel, text) {
-    if ((typeof text === "string" ? new TextEncoder().encode(text).byteLength : text.byteLength) > maxBytes)
+  async function write(channel, text2) {
+    if ((typeof text2 === "string" ? new TextEncoder().encode(text2).byteLength : text2.byteLength) > maxBytes)
       throw new OutputError({
         code: "E_RESULT_TOO_LARGE",
         message: "Result exceeds 8 MiB; read one object or save it to a file."
       });
     await drain();
-    await writer.write(channel, text);
+    await writer.write(channel, text2);
   }
   async function output(value3, kind = "result") {
     const full = {
@@ -759,9 +875,9 @@ async function runCommand(definition, input, options, writer, signal) {
       const key = definition.output.collection;
       if (key && kind === "result") {
         const record = wire.data;
-        const rows = record[key];
-        if (Array.isArray(rows)) {
-          for (const item of rows)
+        const rows2 = record[key];
+        if (Array.isArray(rows2)) {
+          for (const item of rows2)
             await write("stdout", eventLine("item", { collection: key, data: item }));
           const data = { ...record };
           delete data[key];
@@ -793,7 +909,8 @@ async function runCommand(definition, input, options, writer, signal) {
           wire,
           options,
           definition.output.collection,
-          definition.output.requiredFields
+          definition.output.requiredFields,
+          completionState(full.completion).code
         )
       );
     return completionState(full.completion).code;
@@ -877,7 +994,11 @@ async function runCommand(definition, input, options, writer, signal) {
         );
       else if (options.format === "raw" && ctx.payloads.raw !== void 0 && error.code !== "E_RESULT_TOO_LARGE" && Buffer.byteLength(ctx.payloads.raw) <= maxBytes)
         await writer.write("stdout", ctx.payloads.raw);
-      else await writer.write("stderr", renderFailure(wire, options));
+      else
+        await writer.write(
+          "stderr",
+          renderFailure(wire, options, completionState(failure.completion).code)
+        );
       if (options.verbose && err instanceof Error && err.stack)
         await writer.write("stderr", `${err.stack}
 `);
@@ -952,8 +1073,8 @@ function commandLine(pid) {
   if (direct.status === 0 && direct.stdout.trim()) return direct.stdout.trim().split(/\s+/);
   const full = (0, import_node_child_process.spawnSync)("ps", ["-f", "-p", String(pid)], { encoding: "utf8" });
   if (full.status !== 0) return null;
-  const line = full.stdout.split("\n").slice(1).join(" ").trim();
-  return line ? line.split(/\s+/) : null;
+  const line2 = full.stdout.split("\n").slice(1).join(" ").trim();
+  return line2 ? line2.split(/\s+/) : null;
 }
 var isNodeImage = (tasklistLine) => /^"node\.exe"/i.test(tasklistLine.trim());
 function windowsNodeAt(pid) {
@@ -963,10 +1084,10 @@ function windowsNodeAt(pid) {
   });
   return result2.status === 0 && isNodeImage(result2.stdout);
 }
-function hasServerId(pid, id) {
+function hasServerId(pid, id2) {
   if (!alive(pid)) return false;
   if (process.platform === "win32") return windowsNodeAt(pid);
-  return commandLine(pid)?.includes(`--artifacts-server-id=${id}`) ?? false;
+  return commandLine(pid)?.includes(`--artifacts-server-id=${id2}`) ?? false;
 }
 async function waitForExit(pid, ms) {
   for (let waited = 0; waited < ms && alive(pid); waited += 100) await sleep(100);
@@ -1046,24 +1167,263 @@ function serverClient(projectDir) {
   };
 }
 
+// src/cli/output/configuration.ts
+var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_os3 = __toESM(require("node:os"), 1);
+var import_node_path7 = __toESM(require("node:path"), 1);
+
+// src/server/config.ts
+var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
+
+// src/shared/cloud.ts
+var MAX_ARTIFACT_BYTES = 20 * 1024 * 1024;
+var isVisibility = (value3) => value3 === "private" || value3 === "public";
+
+// src/server/state.ts
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+
+// src/shared/types.ts
+var ARTIFACT_TYPES = ["artboard", "document", "html", "whiteboard"];
+
+// src/shared/validate.ts
+var BOARD_NUMBERS = ["x", "y", "w", "h"];
+var BOARD_REQUIRED = ["file", "page", ...BOARD_NUMBERS];
+var MEDIA_REQUIRED = ["src", "page", ...BOARD_NUMBERS];
+
+// src/server/state.ts
+function writeJsonAtomic(file, value3) {
+  import_node_fs4.default.mkdirSync(import_node_path3.default.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(value3, null, 2)}
+`, { mode: 384 });
+  import_node_fs4.default.renameSync(tmp, file);
+}
+
+// src/server/config.ts
+var defaults = () => ({ version: 1, artifacts: {} });
+function isCloudRecord(value3) {
+  if (typeof value3 !== "object" || value3 === null) return false;
+  const { id: id2, url, publishedAt, visibility } = value3;
+  return typeof id2 === "string" && typeof url === "string" && (typeof publishedAt === "string" || publishedAt === null) && isVisibility(visibility);
+}
+function cloudRecord({ id: id2, url, publishedAt, visibility, fingerprint }) {
+  return {
+    id: id2,
+    url,
+    publishedAt,
+    visibility,
+    ...typeof fingerprint === "string" ? { fingerprint } : {}
+  };
+}
+function normalize2(raw) {
+  const config = defaults();
+  if (typeof raw !== "object" || raw === null) return config;
+  const output = raw.output;
+  if (output && typeof output === "object" && "format" in output && ["brief", "json", "jsonl"].includes(String(output.format)))
+    config.output = { format: output.format };
+  const { autoPublish } = raw;
+  if (typeof autoPublish === "boolean") config.autoPublish = autoPublish;
+  const artifacts = raw.artifacts;
+  if (typeof artifacts !== "object" || artifacts === null) return config;
+  for (const [key, value3] of Object.entries(artifacts)) {
+    if (typeof value3 !== "object" || value3 === null) continue;
+    const { visibility, cloud, autoPublish: autoPublish2 } = value3;
+    if (visibility !== void 0 && !isVisibility(visibility)) continue;
+    const entry = {};
+    if (visibility) entry.visibility = visibility;
+    if (isCloudRecord(cloud)) entry.cloud = cloudRecord(cloud);
+    if (autoPublish2 === false) entry.autoPublish = false;
+    config.artifacts[key] = entry;
+  }
+  return config;
+}
+function readConfig(file) {
+  let text2;
+  try {
+    text2 = import_node_fs5.default.readFileSync(file, "utf8");
+  } catch {
+    return { config: defaults() };
+  }
+  try {
+    return { config: normalize2(JSON.parse(text2)) };
+  } catch (err) {
+    return {
+      config: defaults(),
+      warning: `config.json is not valid JSON: ${err.message}`
+    };
+  }
+}
+var IGNORED = ["config.json", "artifacts/*", "!artifacts/document/", "artifacts/document/*/.artifact-id"];
+function ensureGitignore(dir) {
+  const file = import_node_path4.default.join(dir, ".gitignore");
+  let current = "";
+  try {
+    current = import_node_fs5.default.readFileSync(file, "utf8");
+  } catch {
+  }
+  const present = new Set(current.split(/\r?\n/).map((line2) => line2.trim()));
+  const missing = IGNORED.filter((line2) => !present.has(line2));
+  if (missing.length === 0) return;
+  import_node_fs5.default.writeFileSync(file, `${current}${current === "" || current.endsWith("\n") ? "" : "\n"}${missing.join("\n")}
+`);
+}
+function ensureConfig(file) {
+  import_node_fs5.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
+  ensureGitignore(import_node_path4.default.dirname(file));
+  if (!import_node_fs5.default.existsSync(file)) writeJsonAtomic(file, defaults());
+}
+function setProjectAutoPublish(file, value3) {
+  const { config, warning } = readConfig(file);
+  if (warning) throw new Error(warning);
+  if (value3 === null) delete config.autoPublish;
+  else config.autoPublish = value3;
+  import_node_fs5.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
+  writeJsonAtomic(file, config);
+}
+
+// src/server/credentials.ts
+var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
+function credentialsFile(env, platform, home) {
+  if (platform === "win32" && env.APPDATA)
+    return import_node_path5.default.join(env.APPDATA, "ryugi", "credentials.json");
+  return import_node_path5.default.join(env.XDG_CONFIG_HOME || import_node_path5.default.join(home, ".config"), "ryugi", "credentials.json");
+}
+function readCredentials(file, origin) {
+  let raw;
+  try {
+    raw = JSON.parse(import_node_fs6.default.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null) return null;
+  const { origin: savedOrigin, token, login } = raw;
+  if (typeof savedOrigin !== "string" || typeof token !== "string" || typeof login !== "string")
+    return null;
+  if (savedOrigin !== origin) return null;
+  return { origin: savedOrigin, token, login };
+}
+
+// src/server/settings.ts
+var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
+var settingsFileFor = (credentialsFile2) => import_node_path6.default.join(import_node_path6.default.dirname(credentialsFile2), "config.json");
+function readSettings(file) {
+  try {
+    const raw = JSON.parse(import_node_fs7.default.readFileSync(file, "utf8"));
+    return typeof raw === "object" && raw !== null && !Array.isArray(raw) ? raw : {};
+  } catch {
+    return {};
+  }
+}
+function readGlobalAutoPublish(file) {
+  const value3 = readSettings(file).autoPublish;
+  return typeof value3 === "boolean" ? value3 : void 0;
+}
+function writeGlobalAutoPublish(file, value3) {
+  import_node_fs7.default.mkdirSync(import_node_path6.default.dirname(file), { recursive: true, mode: 448 });
+  writeJsonAtomic(file, { ...readSettings(file), autoPublish: value3 });
+}
+
+// src/cli/output/configuration.ts
+var PERSISTED_FORMATS = ["brief", "json", "jsonl"];
+function outputFiles(projectDir) {
+  return {
+    global: settingsFileFor(credentialsFile(process.env, process.platform, import_node_os3.default.homedir())),
+    project: import_node_path7.default.join(import_node_path7.default.dirname(projectPaths(projectDir).root), "config.json")
+  };
+}
+function read(file) {
+  try {
+    const raw = JSON.parse(import_node_fs8.default.readFileSync(file, "utf8"));
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Expected an object");
+    return raw;
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw new OutputError({
+      code: "E_CONFIG_INVALID",
+      message: `Cannot read ${file}: ${error.message}`
+    });
+  }
+}
+function outputValues(projectDir) {
+  const files = outputFiles(projectDir);
+  const get = (file) => {
+    const output = read(file).output;
+    if (output?.format !== void 0 && !PERSISTED_FORMATS.includes(output.format))
+      throw new OutputError({
+        code: "E_FORMAT_UNSUPPORTED",
+        message: `Unsupported output format in ${file}: ${String(output.format)}`
+      });
+    return output && PERSISTED_FORMATS.includes(output.format) ? output.format : null;
+  };
+  const global = get(files.global), project2 = get(files.project);
+  return {
+    global,
+    project: project2,
+    effective: project2 ?? global ?? "brief",
+    source: project2 ? "project" : global ? "global" : "default"
+  };
+}
+function writeOutputFormat(projectDir, isProject, value3) {
+  if (value3 === "inherit" && !isProject || value3 !== "inherit" && !PERSISTED_FORMATS.includes(value3))
+    throw new OutputError({
+      code: "E_ARGUMENT_INVALID",
+      message: "--output-format takes brief, json, jsonl, or inherit with --project."
+    });
+  const files = outputFiles(projectDir), file = isProject ? files.project : files.global, raw = read(file);
+  if (value3 === "inherit") delete raw.output;
+  else raw.output = { format: value3 };
+  if (isProject) ensureConfig(file);
+  else import_node_fs8.default.mkdirSync(import_node_path7.default.dirname(file), { recursive: true, mode: 448 });
+  writeJsonAtomic(file, raw);
+}
+function configuredEnvironment(argv, specs, env = process.env) {
+  if (env.RYUGI_ARTIFACTS_FORMAT !== void 0) return env;
+  const values = scanOptions(argv, specs);
+  if (["format", "json", "quiet", "source"].some((key) => values[key] !== void 0)) return env;
+  let project2 = typeof values["project-dir"] === "string" ? values["project-dir"] : process.cwd();
+  if (!values["project-dir"] && argv[0] && !argv[0].startsWith("-")) {
+    try {
+      if (import_node_fs8.default.statSync(argv[0]).isDirectory()) project2 = argv[0];
+    } catch {
+    }
+  }
+  const config = outputValues(project2);
+  return { ...env, RYUGI_ARTIFACTS_FORMAT: config.effective };
+}
+
 // src/cli/semantic/actions.ts
+var words = (command) => [...command.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)].map((m) => m[1] ?? m[2] ?? m[3]);
+function prefix() {
+  const command = process.env.RYUGI_ARTIFACTS_COMMAND?.trim();
+  return command ? words(command) : [process.execPath, process.argv[1]];
+}
+function configuredFormat(args) {
+  if (process.env.RYUGI_ARTIFACTS_FORMAT) return process.env.RYUGI_ARTIFACTS_FORMAT;
+  const at = args.indexOf("--project-dir");
+  try {
+    return outputValues(at >= 0 && args[at + 1] ? args[at + 1] : process.cwd()).effective;
+  } catch {
+    return "brief";
+  }
+}
 function commandAction(args, label = "Details") {
   const explicit = args.some((arg) => ["--format", "--source", "--quiet"].includes(arg));
-  return {
-    kind: "command",
-    argv: [process.execPath, process.argv[1], ...args, ...explicit ? [] : ["--format", "brief"]],
-    label
-  };
+  const format = explicit || configuredFormat(args) === "brief" ? [] : ["--format", "brief"];
+  return { kind: "command", argv: [...prefix(), ...args, ...format], label };
 }
 
 // src/cli/semantic/files.ts
-var import_node_fs4 = __toESM(require("node:fs"), 1);
-var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_path8 = __toESM(require("node:path"), 1);
 function saveExclusive(target, value3) {
-  const absolute = import_node_path3.default.resolve(target);
+  const absolute = import_node_path8.default.resolve(target);
   let fd;
   try {
-    fd = import_node_fs4.default.openSync(absolute, "wx", 384);
+    fd = import_node_fs9.default.openSync(absolute, "wx", 384);
   } catch (error) {
     throw new OutputError({
       code: error.code === "EEXIST" ? "E_FILE_EXISTS" : "E_FILE_WRITE_FAILED",
@@ -1071,33 +1431,281 @@ function saveExclusive(target, value3) {
     });
   }
   try {
-    import_node_fs4.default.writeFileSync(fd, value3);
+    import_node_fs9.default.writeFileSync(fd, value3);
   } catch (error) {
-    import_node_fs4.default.closeSync(fd);
-    import_node_fs4.default.unlinkSync(absolute);
+    import_node_fs9.default.closeSync(fd);
+    import_node_fs9.default.unlinkSync(absolute);
     throw new OutputError({
       code: "E_FILE_WRITE_FAILED",
       message: `Could not save ${absolute}: ${error.message}`
     });
   }
-  import_node_fs4.default.closeSync(fd);
+  import_node_fs9.default.closeSync(fd);
   return {
     file: absolute,
     bytes: typeof value3 === "string" ? Buffer.byteLength(value3) : value3.byteLength
   };
 }
 
-// src/cli/semantic/review.ts
-var value = (input, key) => typeof input.values[key] === "string" ? input.values[key] : void 0;
-var formats = ["brief", "table", "json", "jsonl", "raw"];
-function artifactOf(input, documentOnly = false) {
-  const artifact = value(input, "artifact");
-  if (!artifact || !(documentOnly ? /^document\/[a-z0-9][a-z0-9-]*$/ : /^(document|artboard|whiteboard)\/[a-z0-9][a-z0-9-]*$/).test(artifact))
-    throw new OutputError({
-      code: "E_ARGUMENT_INVALID",
-      message: documentOnly ? "--artifact must be document/<id>." : "--artifact must be document/<id>, artboard/<id> or whiteboard/<id>."
-    });
-  return artifact;
+// src/cli/semantic/review-view.ts
+var text = (value3) => typeof value3 === "string" ? value3 : "";
+var flat = (value3) => value3.replaceAll(/\s*\n\s*/g, " / ").trim();
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var title = (name) => name[0].toUpperCase() + name.slice(1);
+var counts = (summary, skip = []) => Object.entries(summary ?? {}).filter(
+  ([key, n]) => key !== "waitingOnAgent" && !skip.includes(key) && typeof n === "number" && n > 0
+).map(([key, n]) => `${n} ${key}`).join(", ");
+var bracket = (text2) => text2 ? ` (${text2})` : "";
+var ACTION = {
+  asks: { word: "to apply", none: "nothing to apply", listed: ["submitted"] },
+  groups: { word: "to act on", none: "nothing to act on", listed: [] },
+  rounds: { word: "open or submitted", none: "nothing open", listed: ["open", "submitted"] }
+};
+function sectionSummary(section, report2, page, narrowed = false) {
+  const total = page?.total ?? report2.items.length;
+  const summary = report2.summary;
+  if (narrowed) {
+    const head2 = `${total} matched`;
+    return { head: head2, full: `${head2}${bracket(counts(summary))}`, count: total };
+  }
+  if (section === "threads") {
+    const waiting = Number(summary?.waitingOnAgent ?? 0);
+    const head2 = total ? `${total} unread${waiting ? `, ${waiting} waiting on you` : ""}` : "nothing unread";
+    const resolved = Number(summary?.resolved ?? 0);
+    return {
+      head: head2,
+      full: `${head2}${resolved ? ` (${resolved} resolved)` : ""}`,
+      count: total
+    };
+  }
+  const words2 = ACTION[section];
+  const head = total ? `${total} ${words2.word}` : words2.none;
+  const others = section === "groups" ? Object.entries(summary ?? {}).reduce(
+    (sum, [key, n]) => key === "waitingOnAgent" || typeof n !== "number" ? sum : sum + n,
+    0
+  ) - total : 0;
+  const rest = section === "groups" ? others > 0 ? plural(others, "other") : "" : counts(summary, words2.listed);
+  return { head, full: `${head}${bracket(rest)}`, count: total };
+}
+function location(anchor) {
+  if (!anchor || typeof anchor !== "object") return "";
+  const a = anchor;
+  if (typeof a.blockId === "string") {
+    const blocks = Array.isArray(a.blockIds) && a.blockIds.length > 1 ? a.blockIds : [a.blockId];
+    return `${blocks.length > 1 ? "blocks" : "block"} ${blocks.join(", ")}${text(a.quote) ? ` "${flat(text(a.quote))}"` : ""}`;
+  }
+  if (Array.isArray(a.elements) && a.elements.length) return `element ${a.elements.join(", ")}`;
+  const page = text(a.page);
+  if (typeof a.board === "string") return `${page ? `page ${page} ` : ""}board ${a.board}`;
+  const point = typeof a.x === "number" && typeof a.y === "number" ? ` ${Math.round(a.x)},${Math.round(a.y)}` : "";
+  return `page ${page || "main"}${point}`;
+}
+var id = { key: "id", positional: true, required: true };
+var line = { key: "line", positional: true, required: true };
+var tail = { key: "tail", positional: true, required: true };
+var picked = (item) => item.choice ? ` \u2192 ${item.choice}${item.byRecommendation ? " (recommended)" : ""}` : "";
+function rows(section, items) {
+  if (section === "asks")
+    return {
+      columns: [
+        id,
+        line,
+        { key: "note", label: "note" },
+        { key: "staleChoice", label: "stale choice" }
+      ],
+      rows: items.map((item) => ({
+        ...item,
+        line: `${text(item.state)}${item.choice ? picked(item) : text(item.text) ? ` \xB7 "${flat(text(item.text))}"` : "choice" in item || "text" in item ? " \xB7 no answer" : ""}`,
+        note: text(item.note) && `"${flat(text(item.note))}"`
+      }))
+    };
+  if (section === "threads")
+    return {
+      columns: [
+        id,
+        { key: "status", positional: true, required: true },
+        { key: "waiting", positional: true },
+        { key: "where", positional: true },
+        { key: "stale", label: "stale" },
+        { key: "orphan", label: "orphan" },
+        { key: "draft", label: "draft" },
+        { key: "messageCount", positional: true },
+        { key: "preview", positional: true }
+      ],
+      rows: items.map((item) => ({
+        ...threadFacts(item),
+        messageCount: typeof item.messageCount === "number" && item.messageCount ? plural(item.messageCount, "message") : "",
+        preview: text(item.preview) && `"${flat(text(item.preview))}"`
+      }))
+    };
+  if (section === "groups")
+    return {
+      columns: [
+        id,
+        { key: "kind", positional: true, required: true },
+        line,
+        { key: "evidenceUpdated", label: "evidence updated" },
+        { key: "rejects", positional: true },
+        { key: "threadCount", positional: true },
+        tail
+      ],
+      rows: items.map((item) => ({
+        ...item,
+        line: item.kind === "verify" ? text(item.verdict) : `${item.round ? `round ${item.round}` : ""}${item.choice ? picked(item) : " \xB7 no pick"}`.replace(
+          /^ · /,
+          ""
+        ),
+        rejects: typeof item.rejectThreads === "number" && item.rejectThreads ? plural(item.rejectThreads, "reject thread") : "",
+        threadCount: typeof item.threads === "number" && item.threads ? plural(item.threads, "thread") : "",
+        tail: text(item.title)
+      }))
+    };
+  return {
+    columns: [
+      id,
+      { key: "state", positional: true, required: true },
+      { key: "groupList", positional: true },
+      tail
+    ],
+    rows: items.map((item) => ({
+      ...item,
+      groupList: Array.isArray(item.groups) && item.groups.length ? `groups ${item.groups.join(", ")}` : "",
+      tail: text(item.title)
+    }))
+  };
+}
+function threadFacts(item) {
+  return {
+    id: item.id,
+    status: item.status,
+    waiting: item.waitingOn ? `waiting on ${item.waitingOn}` : "",
+    where: location(
+      item.anchor && typeof item.anchor === "object" && typeof item.page === "string" ? { page: item.page, ...item.anchor } : item.anchor
+    ),
+    stale: item.stale === true,
+    orphan: item.orphan === true,
+    draft: item.draft === true
+  };
+}
+var positional = (key, value3) => ({
+  label: key,
+  binding: { key, value: value3 },
+  positional: true
+});
+function threadMessages(items, key = "items") {
+  return {
+    kind: "messages",
+    key,
+    groups: items.map((item) => {
+      const facts = threadFacts(item);
+      return {
+        facts: [
+          positional("id", facts.id),
+          positional("status", facts.status),
+          positional("waiting", facts.waiting),
+          positional("where", facts.where),
+          { label: "stale", binding: { key: "stale", value: facts.stale } },
+          { label: "orphan", binding: { key: "orphan", value: facts.orphan } },
+          { label: "draft", binding: { key: "draft", value: facts.draft } }
+        ],
+        messages: (Array.isArray(item.messages) ? item.messages : []).map(
+          (message) => ({
+            facts: [
+              positional(
+                "message",
+                [
+                  message.id,
+                  `${text(message.name) || text(message.author)}${message.author === "agent" ? " (agent)" : ""}`,
+                  text(message.at) && formatTime(text(message.at)),
+                  message.deleted ? "(deleted)" : "",
+                  text(message.editedAt) && `edited ${formatTime(text(message.editedAt))}`
+                ].filter(Boolean).join(" ")
+              )
+            ],
+            text: typeof message.text === "string" ? message.text : ""
+          })
+        )
+      };
+    })
+  };
+}
+function sectionView(name, report2, page, inBundle, narrowed) {
+  const summary = sectionSummary(name, report2, page, narrowed);
+  const base = { key: inBundle ? name : "items", title: title(name), summary: summary.full };
+  if (name === "threads" && report2.evidence === "complete")
+    return { ...threadMessages(report2.items), ...base, ...inBundle ? { page } : {} };
+  return {
+    kind: "records",
+    ...rows(name, report2.items),
+    ...base,
+    ...inBundle ? { page } : {}
+  };
+}
+var COLLECTIONS = ["threads", "asks", "groups", "rounds"];
+function summaryView(data, actions) {
+  const summary = data.summary ?? {};
+  const command = (name) => actions.find((action) => action.label === title(name));
+  const listed = COLLECTIONS.filter((name) => command(name));
+  return {
+    heading: "Comment list",
+    status: "",
+    subject: data.artifact,
+    facts: [],
+    sections: listed.map((name) => {
+      const value3 = summary[name];
+      const counted = name === "threads" ? sectionSummary(
+        "threads",
+        { items: [], summary: { waitingOnAgent: summary.waitingOnAgent } },
+        { total: Number(value3 ?? 0) }
+      ).head : counts(value3) || "none";
+      return {
+        kind: "records",
+        key: name,
+        title: title(name),
+        summary: `${counted} \xB7 ${actionText(command(name))}`,
+        columns: [],
+        rows: []
+      };
+    }),
+    actions: actions.filter((action) => !listed.some((name) => title(name) === action.label))
+  };
+}
+function presentRead({ data, actions, coverage }, heading = "Comment list", narrowed = false) {
+  if (data.section === "summary") return summaryView(data, actions);
+  const page = coverage.page;
+  return {
+    heading,
+    status: "",
+    subject: data.artifact,
+    summary: sectionSummary(data.section, data, page, narrowed).head,
+    facts: [],
+    sections: [sectionView(data.section, data, page, false, narrowed)]
+  };
+}
+function presentBundle({ data }, narrowed = false) {
+  const entries = Object.entries(data.sections);
+  const heads = entries.map(([name, entry]) => sectionSummary(name, entry, entry.page, narrowed)).filter((item) => item.count > 0).map((item) => item.head);
+  return {
+    heading: "Comment list",
+    status: "",
+    subject: data.artifact,
+    summary: heads.join(" \xB7 ") || "nothing new",
+    facts: [],
+    sections: entries.map(([name, entry]) => sectionView(name, entry, entry.page, true, narrowed))
+  };
+}
+
+// src/cli/semantic/review.ts
+var value = (input, key) => typeof input.values[key] === "string" ? input.values[key] : void 0;
+var formats = ["brief", "table", "json", "jsonl", "raw"];
+function artifactOf(input, documentOnly = false) {
+  const artifact = value(input, "artifact");
+  if (!artifact || !(documentOnly ? /^document\/[a-z0-9][a-z0-9-]*$/ : /^(document|artboard|whiteboard)\/[a-z0-9][a-z0-9-]*$/).test(artifact))
+    throw new OutputError({
+      code: "E_ARGUMENT_INVALID",
+      message: documentOnly ? "--artifact must be document/<id>." : "--artifact must be document/<id>, artboard/<id> or whiteboard/<id>."
+    });
+  return artifact;
 }
 function query(input) {
   const limit = value(input, "limit");
@@ -1161,83 +1769,11 @@ function ack(input, artifact, endpoint) {
         const response = await call(input, ctx, artifact, endpoint, { op: "ack", receipt });
         return result({ artifact, receipt, status: response.status });
       },
-      present({ data }) {
-        return {
-          heading: "Read acknowledgement",
-          status: data.status,
-          subject: data.artifact,
-          facts: [fact("Receipt", field(data, "receipt"), true)],
-          sections: []
-        };
-      }
+      present: presentAck(endpoint === "review" ? "comment" : "changes")
     },
     input
   );
 }
-function columns(section, items) {
-  const keys = section === "threads" ? [
-    "id",
-    "status",
-    "waitingOn",
-    "anchor",
-    "preview",
-    "messageCount",
-    "stale",
-    ...items.some((item) => "messages" in item) ? ["messages"] : []
-  ] : section === "asks" ? ["id", "state", "choice", "text", "byRecommendation", "staleChoice", "note"] : section === "groups" ? [
-    "id",
-    "kind",
-    "title",
-    "round",
-    "verdict",
-    "choice",
-    "byRecommendation",
-    "by",
-    "evidenceUpdated",
-    "rejectThreads",
-    "threads"
-  ] : ["id", "state", "title", "groups", "submitted"];
-  return keys.map((key) => ({
-    key,
-    label: key,
-    required: ["id", "status", "state", "verdict"].includes(key)
-  }));
-}
-function presentRead({ data }) {
-  return {
-    heading: "Review",
-    status: data.evidence,
-    subject: data.artifact,
-    facts: [
-      fact("Section", field(data, "section"), true),
-      ...data.summary ? [fact("Summary", field(data, "summary"))] : []
-    ],
-    sections: data.section === "summary" ? [] : data.evidence === "complete" ? [messageSection(data.items)] : [
-      {
-        kind: "records",
-        key: "items",
-        rows: data.items,
-        columns: columns(data.section, data.items)
-      }
-    ]
-  };
-}
-function messageSection(items) {
-  const metadata = (item, excluded) => Object.entries(item).filter(([key]) => key !== excluded).map(([key, value3]) => ({ label: key, binding: { key, value: value3 } }));
-  return {
-    kind: "messages",
-    key: "items",
-    groups: items.map((item) => ({
-      facts: metadata(item, "messages"),
-      messages: (Array.isArray(item.messages) ? item.messages : []).map(
-        (message) => ({
-          facts: metadata(message, "text"),
-          text: typeof message.text === "string" ? message.text : JSON.stringify(message.text ?? null)
-        })
-      )
-    }))
-  };
-}
 function bundledReview(input, artifact, operation) {
   if (operation !== "list")
     throw new OutputError({
@@ -1268,9 +1804,6 @@ function bundledReview(input, artifact, operation) {
       output: { formats, detail: true },
       async run(_input, ctx) {
         const json = await call(input, ctx, artifact, "review", { op: "list", sections, ...read2 });
-        const data = {};
-        const actions = [];
-        const omitted = [];
         for (const name of sections) {
           const raw = json.sections?.[name];
           if (!raw || !Array.isArray(raw.items) || typeof raw.snapshot !== "string" || !raw.page || typeof raw.page.scope !== "string" || typeof raw.page.hasMore !== "boolean" || !Number.isInteger(raw.page.returned) || !(raw.page.total === null || Number.isInteger(raw.page.total)))
@@ -1283,41 +1816,69 @@ function bundledReview(input, artifact, operation) {
               code: "E_PROTOCOL_MISMATCH",
               message: "The server returned inconsistent combined review coverage."
             });
-          const report2 = readResult(input, artifact, name, raw, read2);
-          const { artifact: _artifact, section: _section, ...entry } = report2.data;
-          data[name] = { ...entry, page: raw.page };
-          actions.push(
-            ...report2.actions.map((action) => ({
-              ...action,
-              label: `${name} ${action.label ?? "Next"}`
-            }))
-          );
-          if (entry.evidence === "preview" && name === "threads")
-            omitted.push({ path: "data.sections.threads.items.messages", reason: "summary" });
         }
-        return result({ artifact, sections: data }, void 0, { actions, coverage: { omitted } });
+        return bundleResult(input, artifact, sections, json, read2);
       },
-      present({ data }) {
-        return {
-          heading: "Review",
-          status: read2.detail ? "complete" : "preview",
-          subject: artifact,
-          facts: [],
-          sections: Object.entries(data.sections).flatMap(
-            ([name, entry]) => presentRead(result({ ...entry, artifact, section: name })).sections.map((section) => ({
-              ...section,
-              key: name,
-              title: name[0].toUpperCase() + name.slice(1),
-              page: entry.page,
-              status: entry.evidence
-            }))
-          )
-        };
-      }
+      present: (value3) => presentBundle(value3, read2.all)
     },
     input
   );
 }
+var presentAck = (kind) => ({ data }) => ({
+  heading: kind === "comment" ? "Comment ack" : "Changes ack",
+  status: data.status,
+  subject: data.artifact,
+  facts: [],
+  sections: []
+});
+function presentChanges({ data }) {
+  const count = data.blocks.length;
+  return {
+    heading: "Changes",
+    status: data.saved ? "saved" : "",
+    subject: data.artifact,
+    summary: data.empty ? "no human edits" : data.diff === void 0 ? `${count} block${count === 1 ? "" : "s"} changed` : "complete diff",
+    facts: data.saved ? [fact("File", field(data, "saved"), true)] : [],
+    sections: data.empty || data.saved ? [] : data.diff === void 0 ? [
+      {
+        kind: "records",
+        key: "blocks",
+        rows: data.blocks.map((block) => ({
+          id: block.id,
+          size: [
+            block.additions && `+${block.additions}`,
+            block.deletions && `-${block.deletions}`
+          ].filter(Boolean).join(" "),
+          preview: block.preview && `"${block.preview.replaceAll(/\s*\n\s*/g, " / ")}"`
+        })),
+        columns: [
+          { key: "id", positional: true, required: true },
+          { key: "size", positional: true },
+          { key: "preview", positional: true }
+        ]
+      }
+    ] : [{ kind: "diff", key: "diff", text: data.diff }]
+  };
+}
+function bundleResult(input, artifact, sections, json, read2) {
+  const data = {};
+  const actions = [];
+  const omitted = [];
+  for (const name of sections) {
+    const raw = json.sections[name];
+    const report2 = readResult(input, artifact, name, raw, read2);
+    const { artifact: _artifact, section: _section, ...entry } = report2.data;
+    data[name] = { ...entry, page: raw.page };
+    actions.push(
+      ...report2.actions.map(
+        (action) => action.label === "More" ? { ...action, label: `More (${name})` } : action
+      )
+    );
+    if (entry.evidence === "preview" && name === "threads")
+      omitted.push({ path: "data.sections.threads.items.messages", reason: "summary" });
+  }
+  return result({ artifact, sections: data }, void 0, { actions, coverage: { omitted } });
+}
 function readResult(input, artifact, section, json, read2, thread) {
   const page = json.page;
   const data = {
@@ -1373,14 +1934,18 @@ function readResult(input, artifact, section, json, read2, thread) {
           ...read2.all ? ["--all"] : [],
           ...value(input, "limit") ? ["--limit", value(input, "limit")] : []
         ],
-        "Review"
+        "Review all"
+      )
+    );
+    const collections = artifact.startsWith("document/") ? ["threads", "asks"] : artifact.startsWith("artboard/") ? ["threads", "groups", "rounds"] : ["threads"];
+    actions.unshift(
+      ...collections.map(
+        (name) => commandAction(
+          ["comment", "list", ...args, "--section", name, ...name === "asks" ? ["--detail"] : []],
+          name[0].toUpperCase() + name.slice(1)
+        )
       )
     );
-    actions.push(commandAction(["comment", "list", ...args, "--section", "threads"], "Threads"));
-    if (artifact.startsWith("document/"))
-      actions.push(
-        commandAction(["comment", "list", ...args, "--section", "asks", "--detail"], "Answers")
-      );
   } else if (section === "threads" && data.evidence === "preview" && data.items[0])
     actions.push(
       commandAction(
@@ -1397,6 +1962,16 @@ function readResult(input, artifact, section, json, read2, thread) {
         "Read"
       )
     );
+  if (section === "asks" && data.items.some((item) => item.state === "submitted"))
+    actions.unshift({
+      ...commandAction(["comment", "note", ...args, "--ask", "<id>"], "Next"),
+      reason: "apply each answer, then settle it"
+    });
+  if (section === "groups" && data.items.some((item) => item.kind === "choose" && item.choice || item.verdict === "reject"))
+    actions.unshift({
+      ...commandAction(["comment", "list", ...args, "--section", "threads", "--detail"], "Next"),
+      reason: "read the threads on these groups too, then act on each"
+    });
   return result(data, void 0, {
     actions,
     coverage: {
@@ -1455,7 +2030,11 @@ function reviewSemantic(input) {
         });
         return readResult(input, artifact, section, json, read2, thread);
       },
-      present: presentRead
+      present: (report2) => presentRead(
+        report2,
+        operation === "read" ? "Comment read" : "Comment list",
+        read2.all || !!value(input, "status") && !(section === "asks" && value(input, "status") === "submitted") || !!value(input, "choice-state")
+      )
     },
     input
   );
@@ -1534,31 +2113,7 @@ function changesSemantic(input) {
           }
         });
       },
-      present({ data }) {
-        return {
-          heading: "Changes",
-          status: data.empty ? "unchanged" : data.saved ? "saved" : data.diff === void 0 ? "preview" : "complete",
-          subject: data.artifact,
-          facts: [
-            ...data.saved ? [fact("File", field(data, "saved"), true)] : [],
-            ...data.receipt ? [fact("Receipt", field(data, "receipt"), true)] : []
-          ],
-          sections: data.diff === void 0 ? [
-            {
-              kind: "records",
-              key: "blocks",
-              rows: data.blocks.map((block) => ({ ...block })),
-              columns: [
-                { key: "id", label: "ID", required: true },
-                { key: "kind", label: "Kind" },
-                { key: "additions", label: "+" },
-                { key: "deletions", label: "-" },
-                { key: "preview", label: "Preview" }
-              ]
-            }
-          ] : [{ kind: "diff", key: "diff", title: "Complete diff", text: data.diff }]
-        };
-      }
+      present: presentChanges
     },
     input
   );
@@ -1630,15 +2185,15 @@ function analyzeCheck(artifact, evidence) {
   }));
   const pending = [...evidence.pending ?? []];
   if (evidence.merging) pending.push("merging");
-  for (const [id, state] of Object.entries(evidence.recordings ?? {})) {
+  for (const [id2, state] of Object.entries(evidence.recordings ?? {})) {
     if (state.warning)
       issues.push({
         code: "W_RECORDING",
         severity: "warning",
         message: state.warning,
-        location: id
+        location: id2
       });
-    if (state.status === "processing") pending.push(`recording:${id}`);
+    if (state.status === "processing") pending.push(`recording:${id2}`);
   }
   const dynamic = Object.entries(evidence.dynamic ?? {});
   const required = evidence.evidence?.required ?? (artifact.startsWith("html/") || artifact.startsWith("artboard/") || dynamic.length > 0);
@@ -1732,26 +2287,28 @@ var checkCommand = {
         ];
         return value3;
       },
-      present({ data }) {
-        return {
-          heading: "Check",
-          status: data.status,
-          subject: data.artifact,
-          facts: [
-            fact("Static", field(data, "static")),
-            fact("Browser", field(data, "runtime")),
-            ...data.pending.length ? [fact("Pending", field(data, "pending"))] : []
-          ],
-          sections: [{ kind: "diagnostics", key: "issues", items: data.issues, preview: 3 }]
-        };
-      }
+      present: presentCheck
     },
     input
   )
 };
+function presentCheck({ data }) {
+  const count = data.issues.length;
+  return {
+    heading: "Check",
+    status: data.status,
+    subject: data.artifact,
+    summary: count ? `${count} issue${count === 1 ? "" : "s"}` : "",
+    facts: [
+      ...data.runtime === "not_run" || data.runtime === "unknown" ? [fact("Browser", { key: "runtime", value: data.runtime.replaceAll("_", " ") })] : [],
+      ...data.pending.length ? [fact("Pending", { key: "pending", value: data.pending.join(", ") })] : []
+    ],
+    sections: [{ kind: "diagnostics", key: "issues", items: data.issues, preview: 3 }]
+  };
+}
 
 // src/cli/comment.ts
-var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_fs10 = __toESM(require("node:fs"), 1);
 
 // src/cli/comment-asks.ts
 function askRequest(action, options, message, optionalText) {
@@ -1770,6 +2327,20 @@ function askRequest(action, options, message, optionalText) {
 }
 
 // src/cli/semantic/comment.ts
+function presentWrite({ data }) {
+  const target = data.threadId ? `thread ${data.threadId}` : data.ask ? `ask ${data.ask}` : data.group ? `group ${data.group}${data.board ? ` \u2192 ${data.board}` : ""}` : data.round ? `round ${data.round}` : "";
+  return {
+    heading: `Comment ${data.operation}`,
+    status: data.status,
+    subject: data.artifact,
+    summary: `${target}${data.operation === "answer" && data.choice ? ` \u2192 ${data.choice}` : ""}`,
+    facts: [
+      ...data.messageId ? [fact("Message", field(data, "messageId"))] : [],
+      ...data.groups?.length ? [fact("Groups", { key: "groups", value: data.groups.join(", ") })] : []
+    ],
+    sections: []
+  };
+}
 function commentOptions(input) {
   const options = {
     action: input.positionals[0],
@@ -1870,22 +2441,7 @@ function commentSemantic(input) {
         };
         return result(data, void 0, { effects: ctx.effects.snapshot() });
       },
-      present({ data }) {
-        return {
-          heading: data.operation === "pass" || data.operation === "reject" ? "Verdict" : "Review",
-          status: data.status,
-          subject: data.artifact,
-          facts: [
-            fact("Operation", field(data, "operation"), true),
-            fact("By", field(data, "by"), true),
-            ...data.threadId ? [fact("Thread", field(data, "threadId"), true)] : [],
-            ...data.messageId ? [fact("Message", field(data, "messageId"))] : [],
-            ...data.ask ? [fact("Question", field(data, "ask"), true)] : [],
-            ...data.group ? [fact("Group", field(data, "group"), true)] : []
-          ],
-          sections: []
-        };
-      }
+      present: presentWrite
     },
     input
   );
@@ -1908,15 +2464,15 @@ var VERDICTS = /* @__PURE__ */ new Set(["pass", "reject"]);
 function readStdin() {
   if (process.stdin.isTTY) return "";
   try {
-    return import_node_fs5.default.readFileSync(0, "utf8");
+    return import_node_fs10.default.readFileSync(0, "utf8");
   } catch {
     return "";
   }
 }
 function messageText(options) {
-  const text = (options.text ?? readStdin()).trim();
-  if (!text) throw new CliError("The message is empty: pass --text <text> or pipe it on stdin");
-  return text;
+  const text2 = (options.text ?? readStdin()).trim();
+  if (!text2) throw new CliError("The message is empty: pass --text <text> or pipe it on stdin");
+  return text2;
 }
 function coordinate(value3, flag) {
   if (value3 === void 0) return void 0;
@@ -1937,12 +2493,12 @@ function requestOf(options, action, type) {
       throw new CliError(
         action === "pass" ? "comment pass needs --group <groupId>, or --all" : "comment reject needs --group <groupId>"
       );
-    const text = action === "reject" ? messageText(options) : options.text?.trim();
+    const text2 = action === "reject" ? messageText(options) : options.text?.trim();
     return {
       op: "verdict",
       verdict: action,
       ...all ? { all: true } : { group: options.group },
-      ...text ? { text } : {}
+      ...text2 ? { text: text2 } : {}
     };
   }
   if (action === "choose") {
@@ -1987,378 +2543,151 @@ function requestOf(options, action, type) {
       op: "add",
       blockId: options.block,
       ...options.quote ? { quote: options.quote } : {},
-      text: messageText(options)
-    };
-  }
-  if (!options.thread) throw new CliError(`comment ${action} needs --thread <threadId>`);
-  return action === "reply" ? { op: "reply", threadId: options.thread, text: messageText(options) } : { op: "resolve", threadId: options.thread };
-}
-function prepareComment(options) {
-  const action = COMMENT_ACTIONS.find((name) => name === options.action);
-  if (!action)
-    throw new CliError(
-      "comment needs an action: list, add, reply, resolve, choose, submit, answer, note, pass or reject"
-    );
-  if (!options.artifact || !ARTIFACT.test(options.artifact))
-    throw new CliError("--artifact must be document/<id>, artboard/<id> or whiteboard/<id>");
-  const [type, id] = options.artifact.split("/");
-  const request = requestOf(options, action, type);
-  return { action, type, id, request, artifact: options.artifact };
-}
-async function callComment(options, prepared, signal) {
-  const { type, id, request } = prepared;
-  const server = serverClient(options.projectDir);
-  const agent = detectAgent(process.env);
-  return server.call(
-    "POST",
-    `/api/agent/${type}/${id}/comments`,
-    {
-      ...request,
-      ...agent ? { agent } : {}
-    },
-    signal
-  );
-}
-var commentCommand = {
-  semantic: commentSemantic,
-  name: "comment",
-  summary: "Read and answer comments on a document, artboard or whiteboard (needs a running server)",
-  usage: [
-    "list    --artifact <document|artboard|whiteboard>/<id> --sections all|<names> [--detail] [--all]",
-    "list    --artifact <document|artboard|whiteboard>/<id> [--section threads|asks|groups|rounds] [--all]",
-    "read    --artifact <document|artboard|whiteboard>/<id> --thread <threadId> [--snapshot <token>]",
-    "ack     --artifact <document|artboard|whiteboard>/<id> --receipt <receipt>",
-    "add     --artifact document/<id> --block <blockId> [--quote <text>] [--text <text>]",
-    "add     --artifact artboard/<id> --board <boardId> [--x <px> --y <px>] [--text <text>]",
-    "add     --artifact whiteboard/<id> (--element <elementId> | --x <px> --y <px> [--page <pageId>]) [--text <text>]",
-    "reply   --artifact <document|artboard|whiteboard>/<id> --thread <threadId> [--text <text>]",
-    "resolve --artifact <document|artboard|whiteboard>/<id> --thread <threadId>",
-    "choose  --artifact artboard/<id> --group <groupId> (--board <boardId> | --clear)",
-    "submit  --artifact artboard/<id> --round <roundId> [--withdraw]",
-    "submit  --artifact document/<id> [--withdraw]",
-    "answer  --artifact document/<id> --ask <questionId> (--choice <value> | --text <answer> | --clear)",
-    "note    --artifact document/<id> --ask <questionId> [--text <note>]",
-    "pass    --artifact artboard/<id> (--group <groupId> | --all) [--text <text>]",
-    "reject  --artifact artboard/<id> --group <groupId> [--text <text>]"
-  ],
-  details: "list returns a summary; select threads, asks, groups or rounds to read one collection. Previews do not consume evidence. read returns a complete thread and receipt; use ack after applying that evidence. asks, groups and rounds are independent state reads without receipts. Without --text, add, reply, note and reject read the message from stdin. answer records what your human partner said in the terminal; note settles a question once its answer is applied. pass and reject record a verdict on a verify group only when your human partner asks for it; the board shows the agent recorded it.",
-  options: {
-    "sections": {
-      type: "string",
-      value: "<all|threads,asks|threads,groups,rounds>",
-      help: "Read multiple bounded review collections in one request"
-    },
-    "section": {
-      type: "string",
-      value: "<threads|asks|groups|rounds>",
-      help: "Semantic list: select one review collection"
-    },
-    "limit": {
-      type: "string",
-      value: "<n>",
-      help: "Semantic reads: records per page (1\u2013100, default 10)"
-    },
-    "cursor": { type: "string", value: "<cursor>", help: "Continue a semantic snapshot page" },
-    "snapshot": { type: "string", value: "<snapshot>", help: "Read an existing semantic snapshot" },
-    "receipt": {
-      type: "string",
-      value: "<receipt>",
-      help: "ack: confirm exactly the complete evidence delivered"
-    },
-    "status": {
-      type: "string",
-      value: "<status>",
-      help: "Filter the selected semantic review collection"
-    },
-    "waiting-on": {
-      type: "string",
-      value: "<agent|human|any>",
-      help: "Filter unread threads by who should reply"
-    },
-    "kind": { type: "string", value: "<verify|choose>", help: "Filter review groups by kind" },
-    "choice-state": { type: "string", value: "<chosen|empty>", help: "Filter choice groups" },
-    "artifact": { type: "string", value: "<type>/<id>", help: "The document or artboard" },
-    "all": {
-      type: "boolean",
-      help: "list: every thread, not only what changed; pass: every verify group not yet passed"
-    },
-    "block": { type: "string", value: "<blockId>", help: "add: the document block to comment on" },
-    "quote": {
-      type: "string",
-      value: "<text>",
-      help: "add: the text in the block the comment is about"
-    },
-    "board": { type: "string", value: "<boardId>", help: "add: the artboard board to comment on" },
-    "element": {
-      type: "string",
-      value: "<elementId>",
-      help: "add: the whiteboard element to comment on"
-    },
-    "page": {
-      type: "string",
-      value: "<pageId>",
-      help: "add: the whiteboard page --x and --y are on (default main)"
-    },
-    "x": { type: "string", value: "<px>", help: "add: horizontal position on the board" },
-    "y": { type: "string", value: "<px>", help: "add: vertical position on the board" },
-    "thread": { type: "string", value: "<threadId>", help: "reply, resolve: the thread" },
-    "text": {
-      type: "string",
-      value: "<text>",
-      help: "add, reply, note: the message; answer: a written answer; reject: the reason; pass: an optional note"
-    },
-    "group": {
-      type: "string",
-      value: "<groupId>",
-      help: "choose: the choice group; pass, reject: the verify group"
-    },
-    "clear": { type: "boolean", help: "choose, answer: clear the choice or answer" },
-    "ask": { type: "string", value: "<questionId>", help: "answer, note: the question id" },
-    "choice": { type: "string", value: "<value>", help: "answer: the option value" },
-    "round": { type: "string", value: "<roundId>", help: "submit: the round" },
-    "withdraw": { type: "boolean", help: "submit: withdraw the submission" }
-  },
-  positionals: 1
-};
-
-// src/cli/config.ts
-var import_node_os4 = __toESM(require("node:os"), 1);
-var import_node_path9 = __toESM(require("node:path"), 1);
-
-// src/server/config.ts
-var import_node_fs7 = __toESM(require("node:fs"), 1);
-var import_node_path5 = __toESM(require("node:path"), 1);
-
-// src/shared/cloud.ts
-var MAX_ARTIFACT_BYTES = 20 * 1024 * 1024;
-var isVisibility = (value3) => value3 === "private" || value3 === "public";
-
-// src/server/state.ts
-var import_node_fs6 = __toESM(require("node:fs"), 1);
-var import_node_path4 = __toESM(require("node:path"), 1);
-
-// src/shared/types.ts
-var ARTIFACT_TYPES = ["artboard", "document", "html", "whiteboard"];
-
-// src/shared/validate.ts
-var BOARD_NUMBERS = ["x", "y", "w", "h"];
-var BOARD_REQUIRED = ["file", "page", ...BOARD_NUMBERS];
-var MEDIA_REQUIRED = ["src", "page", ...BOARD_NUMBERS];
-
-// src/server/state.ts
-function writeJsonAtomic(file, value3) {
-  import_node_fs6.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
-  const tmp = `${file}.${process.pid}.tmp`;
-  import_node_fs6.default.writeFileSync(tmp, `${JSON.stringify(value3, null, 2)}
-`, { mode: 384 });
-  import_node_fs6.default.renameSync(tmp, file);
-}
-
-// src/server/config.ts
-var defaults = () => ({ version: 1, artifacts: {} });
-function isCloudRecord(value3) {
-  if (typeof value3 !== "object" || value3 === null) return false;
-  const { id, url, publishedAt, visibility } = value3;
-  return typeof id === "string" && typeof url === "string" && (typeof publishedAt === "string" || publishedAt === null) && isVisibility(visibility);
-}
-function cloudRecord({ id, url, publishedAt, visibility, fingerprint }) {
-  return {
-    id,
-    url,
-    publishedAt,
-    visibility,
-    ...typeof fingerprint === "string" ? { fingerprint } : {}
-  };
-}
-function normalize2(raw) {
-  const config = defaults();
-  if (typeof raw !== "object" || raw === null) return config;
-  const output = raw.output;
-  if (output && typeof output === "object" && "format" in output && ["brief", "json", "jsonl"].includes(String(output.format)))
-    config.output = { format: output.format };
-  const { autoPublish } = raw;
-  if (typeof autoPublish === "boolean") config.autoPublish = autoPublish;
-  const artifacts = raw.artifacts;
-  if (typeof artifacts !== "object" || artifacts === null) return config;
-  for (const [key, value3] of Object.entries(artifacts)) {
-    if (typeof value3 !== "object" || value3 === null) continue;
-    const { visibility, cloud, autoPublish: autoPublish2 } = value3;
-    if (visibility !== void 0 && !isVisibility(visibility)) continue;
-    const entry = {};
-    if (visibility) entry.visibility = visibility;
-    if (isCloudRecord(cloud)) entry.cloud = cloudRecord(cloud);
-    if (autoPublish2 === false) entry.autoPublish = false;
-    config.artifacts[key] = entry;
-  }
-  return config;
-}
-function readConfig(file) {
-  let text;
-  try {
-    text = import_node_fs7.default.readFileSync(file, "utf8");
-  } catch {
-    return { config: defaults() };
-  }
-  try {
-    return { config: normalize2(JSON.parse(text)) };
-  } catch (err) {
-    return {
-      config: defaults(),
-      warning: `config.json is not valid JSON: ${err.message}`
-    };
-  }
-}
-var IGNORED = ["config.json", "artifacts/*", "!artifacts/document/", "artifacts/document/*/.artifact-id"];
-function ensureGitignore(dir) {
-  const file = import_node_path5.default.join(dir, ".gitignore");
-  let current = "";
-  try {
-    current = import_node_fs7.default.readFileSync(file, "utf8");
-  } catch {
-  }
-  const present2 = new Set(current.split(/\r?\n/).map((line) => line.trim()));
-  const missing = IGNORED.filter((line) => !present2.has(line));
-  if (missing.length === 0) return;
-  import_node_fs7.default.writeFileSync(file, `${current}${current === "" || current.endsWith("\n") ? "" : "\n"}${missing.join("\n")}
-`);
-}
-function ensureConfig(file) {
-  import_node_fs7.default.mkdirSync(import_node_path5.default.dirname(file), { recursive: true });
-  ensureGitignore(import_node_path5.default.dirname(file));
-  if (!import_node_fs7.default.existsSync(file)) writeJsonAtomic(file, defaults());
-}
-function setProjectAutoPublish(file, value3) {
-  const { config, warning } = readConfig(file);
-  if (warning) throw new Error(warning);
-  if (value3 === null) delete config.autoPublish;
-  else config.autoPublish = value3;
-  import_node_fs7.default.mkdirSync(import_node_path5.default.dirname(file), { recursive: true });
-  writeJsonAtomic(file, config);
-}
-
-// src/server/credentials.ts
-var import_node_fs8 = __toESM(require("node:fs"), 1);
-var import_node_path6 = __toESM(require("node:path"), 1);
-function credentialsFile(env, platform, home) {
-  if (platform === "win32" && env.APPDATA)
-    return import_node_path6.default.join(env.APPDATA, "ryugi", "credentials.json");
-  return import_node_path6.default.join(env.XDG_CONFIG_HOME || import_node_path6.default.join(home, ".config"), "ryugi", "credentials.json");
-}
-function readCredentials(file, origin) {
-  let raw;
-  try {
-    raw = JSON.parse(import_node_fs8.default.readFileSync(file, "utf8"));
-  } catch {
-    return null;
-  }
-  if (typeof raw !== "object" || raw === null) return null;
-  const { origin: savedOrigin, token, login } = raw;
-  if (typeof savedOrigin !== "string" || typeof token !== "string" || typeof login !== "string")
-    return null;
-  if (savedOrigin !== origin) return null;
-  return { origin: savedOrigin, token, login };
-}
-
-// src/server/settings.ts
-var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_path7 = __toESM(require("node:path"), 1);
-var settingsFileFor = (credentialsFile2) => import_node_path7.default.join(import_node_path7.default.dirname(credentialsFile2), "config.json");
-function readSettings(file) {
-  try {
-    const raw = JSON.parse(import_node_fs9.default.readFileSync(file, "utf8"));
-    return typeof raw === "object" && raw !== null && !Array.isArray(raw) ? raw : {};
-  } catch {
-    return {};
-  }
-}
-function readGlobalAutoPublish(file) {
-  const value3 = readSettings(file).autoPublish;
-  return typeof value3 === "boolean" ? value3 : void 0;
-}
-function writeGlobalAutoPublish(file, value3) {
-  import_node_fs9.default.mkdirSync(import_node_path7.default.dirname(file), { recursive: true, mode: 448 });
-  writeJsonAtomic(file, { ...readSettings(file), autoPublish: value3 });
-}
-
-// src/cli/output/configuration.ts
-var import_node_fs10 = __toESM(require("node:fs"), 1);
-var import_node_os3 = __toESM(require("node:os"), 1);
-var import_node_path8 = __toESM(require("node:path"), 1);
-var PERSISTED_FORMATS = ["brief", "json", "jsonl"];
-function outputFiles(projectDir) {
-  return {
-    global: settingsFileFor(credentialsFile(process.env, process.platform, import_node_os3.default.homedir())),
-    project: import_node_path8.default.join(import_node_path8.default.dirname(projectPaths(projectDir).root), "config.json")
-  };
-}
-function read(file) {
-  try {
-    const raw = JSON.parse(import_node_fs10.default.readFileSync(file, "utf8"));
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Expected an object");
-    return raw;
-  } catch (error) {
-    if (error.code === "ENOENT") return {};
-    throw new OutputError({
-      code: "E_CONFIG_INVALID",
-      message: `Cannot read ${file}: ${error.message}`
-    });
-  }
-}
-function outputValues(projectDir) {
-  const files = outputFiles(projectDir);
-  const get = (file) => {
-    const output = read(file).output;
-    if (output?.format !== void 0 && !PERSISTED_FORMATS.includes(output.format))
-      throw new OutputError({
-        code: "E_FORMAT_UNSUPPORTED",
-        message: `Unsupported output format in ${file}: ${String(output.format)}`
-      });
-    return output && PERSISTED_FORMATS.includes(output.format) ? output.format : null;
-  };
-  const global = get(files.global), project2 = get(files.project);
-  return {
-    global,
-    project: project2,
-    effective: project2 ?? global ?? "brief",
-    source: project2 ? "project" : global ? "global" : "default"
-  };
+      text: messageText(options)
+    };
+  }
+  if (!options.thread) throw new CliError(`comment ${action} needs --thread <threadId>`);
+  return action === "reply" ? { op: "reply", threadId: options.thread, text: messageText(options) } : { op: "resolve", threadId: options.thread };
 }
-function writeOutputFormat(projectDir, isProject, value3) {
-  if (value3 === "inherit" && !isProject || value3 !== "inherit" && !PERSISTED_FORMATS.includes(value3))
-    throw new OutputError({
-      code: "E_ARGUMENT_INVALID",
-      message: "--output-format takes brief, json, jsonl, or inherit with --project."
-    });
-  const files = outputFiles(projectDir), file = isProject ? files.project : files.global, raw = read(file);
-  if (value3 === "inherit") delete raw.output;
-  else raw.output = { format: value3 };
-  if (isProject) ensureConfig(file);
-  else import_node_fs10.default.mkdirSync(import_node_path8.default.dirname(file), { recursive: true, mode: 448 });
-  writeJsonAtomic(file, raw);
+function prepareComment(options) {
+  const action = COMMENT_ACTIONS.find((name) => name === options.action);
+  if (!action)
+    throw new CliError(
+      "comment needs an action: list, add, reply, resolve, choose, submit, answer, note, pass or reject"
+    );
+  if (!options.artifact || !ARTIFACT.test(options.artifact))
+    throw new CliError("--artifact must be document/<id>, artboard/<id> or whiteboard/<id>");
+  const [type, id2] = options.artifact.split("/");
+  const request = requestOf(options, action, type);
+  return { action, type, id: id2, request, artifact: options.artifact };
 }
-function configuredEnvironment(argv, specs, env = process.env) {
-  if (env.RYUGI_ARTIFACTS_FORMAT !== void 0) return env;
-  const values = scanOptions(argv, specs);
-  if (["format", "json", "quiet", "source"].some((key) => values[key] !== void 0)) return env;
-  let project2 = typeof values["project-dir"] === "string" ? values["project-dir"] : process.cwd();
-  if (!values["project-dir"] && argv[0] && !argv[0].startsWith("-")) {
-    try {
-      if (import_node_fs10.default.statSync(argv[0]).isDirectory()) project2 = argv[0];
-    } catch {
-    }
-  }
-  const config = outputValues(project2);
-  return { ...env, RYUGI_ARTIFACTS_FORMAT: config.effective };
+async function callComment(options, prepared, signal) {
+  const { type, id: id2, request } = prepared;
+  const server = serverClient(options.projectDir);
+  const agent = detectAgent(process.env);
+  return server.call(
+    "POST",
+    `/api/agent/${type}/${id2}/comments`,
+    {
+      ...request,
+      ...agent ? { agent } : {}
+    },
+    signal
+  );
 }
+var commentCommand = {
+  semantic: commentSemantic,
+  name: "comment",
+  summary: "Read and answer comments on a document, artboard or whiteboard (needs a running server)",
+  usage: [
+    "list    --artifact <document|artboard|whiteboard>/<id> --sections all|<names> [--detail] [--all]",
+    "list    --artifact <document|artboard|whiteboard>/<id> [--section threads|asks|groups|rounds] [--all]",
+    "read    --artifact <document|artboard|whiteboard>/<id> --thread <threadId> [--snapshot <token>]",
+    "ack     --artifact <document|artboard|whiteboard>/<id> --receipt <receipt>",
+    "add     --artifact document/<id> --block <blockId> [--quote <text>] [--text <text>]",
+    "add     --artifact artboard/<id> --board <boardId> [--x <px> --y <px>] [--text <text>]",
+    "add     --artifact whiteboard/<id> (--element <elementId> | --x <px> --y <px> [--page <pageId>]) [--text <text>]",
+    "reply   --artifact <document|artboard|whiteboard>/<id> --thread <threadId> [--text <text>]",
+    "resolve --artifact <document|artboard|whiteboard>/<id> --thread <threadId>",
+    "choose  --artifact artboard/<id> --group <groupId> (--board <boardId> | --clear)",
+    "submit  --artifact artboard/<id> --round <roundId> [--withdraw]",
+    "submit  --artifact document/<id> [--withdraw]",
+    "answer  --artifact document/<id> --ask <questionId> (--choice <value> | --text <answer> | --clear)",
+    "note    --artifact document/<id> --ask <questionId> [--text <note>]",
+    "pass    --artifact artboard/<id> (--group <groupId> | --all) [--text <text>]",
+    "reject  --artifact artboard/<id> --group <groupId> [--text <text>]"
+  ],
+  details: "list returns a summary; select threads, asks, groups or rounds to read one collection. Previews do not consume evidence. read returns a complete thread and receipt; use ack after applying that evidence. asks, groups and rounds are independent state reads without receipts. Without --text, add, reply, note and reject read the message from stdin. answer records what your human partner said in the terminal; note settles a question once its answer is applied. pass and reject record a verdict on a verify group only when your human partner asks for it; the board shows the agent recorded it.",
+  options: {
+    "sections": {
+      type: "string",
+      value: "<all|threads,asks|threads,groups,rounds>",
+      help: "Read multiple bounded review collections in one request"
+    },
+    "section": {
+      type: "string",
+      value: "<threads|asks|groups|rounds>",
+      help: "Semantic list: select one review collection"
+    },
+    "limit": {
+      type: "string",
+      value: "<n>",
+      help: "Semantic reads: records per page (1\u2013100, default 10)"
+    },
+    "cursor": { type: "string", value: "<cursor>", help: "Continue a semantic snapshot page" },
+    "snapshot": { type: "string", value: "<snapshot>", help: "Read an existing semantic snapshot" },
+    "receipt": {
+      type: "string",
+      value: "<receipt>",
+      help: "ack: confirm exactly the complete evidence delivered"
+    },
+    "status": {
+      type: "string",
+      value: "<status>",
+      help: "Filter the selected semantic review collection"
+    },
+    "waiting-on": {
+      type: "string",
+      value: "<agent|human|any>",
+      help: "Filter unread threads by who should reply"
+    },
+    "kind": { type: "string", value: "<verify|choose>", help: "Filter review groups by kind" },
+    "choice-state": { type: "string", value: "<chosen|empty>", help: "Filter choice groups" },
+    "artifact": { type: "string", value: "<type>/<id>", help: "The document or artboard" },
+    "all": {
+      type: "boolean",
+      help: "list: every thread, not only what changed; pass: every verify group not yet passed"
+    },
+    "block": { type: "string", value: "<blockId>", help: "add: the document block to comment on" },
+    "quote": {
+      type: "string",
+      value: "<text>",
+      help: "add: the text in the block the comment is about"
+    },
+    "board": { type: "string", value: "<boardId>", help: "add: the artboard board to comment on" },
+    "element": {
+      type: "string",
+      value: "<elementId>",
+      help: "add: the whiteboard element to comment on"
+    },
+    "page": {
+      type: "string",
+      value: "<pageId>",
+      help: "add: the whiteboard page --x and --y are on (default main)"
+    },
+    "x": { type: "string", value: "<px>", help: "add: horizontal position on the board" },
+    "y": { type: "string", value: "<px>", help: "add: vertical position on the board" },
+    "thread": { type: "string", value: "<threadId>", help: "reply, resolve: the thread" },
+    "text": {
+      type: "string",
+      value: "<text>",
+      help: "add, reply, note: the message; answer: a written answer; reject: the reason; pass: an optional note"
+    },
+    "group": {
+      type: "string",
+      value: "<groupId>",
+      help: "choose: the choice group; pass, reject: the verify group"
+    },
+    "clear": { type: "boolean", help: "choose, answer: clear the choice or answer" },
+    "ask": { type: "string", value: "<questionId>", help: "answer, note: the question id" },
+    "choice": { type: "string", value: "<value>", help: "answer: the option value" },
+    "round": { type: "string", value: "<roundId>", help: "submit: the round" },
+    "withdraw": { type: "boolean", help: "submit: withdraw the submission" }
+  },
+  positionals: 1
+};
 
 // src/cli/config.ts
+var import_node_os4 = __toESM(require("node:os"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
 var VALUES = { on: true, off: false, inherit: null };
 function configure(options) {
   const globalFile = settingsFileFor(credentialsFile(process.env, process.platform, import_node_os4.default.homedir()));
   const projectFile = import_node_path9.default.join(import_node_path9.default.dirname(projectPaths(options.projectDir).root), "config.json");
   if (options.autoPublish !== void 0) {
     const value3 = VALUES[options.autoPublish];
-    if (value3 === void 0) throw new CliError("--auto-publish takes on, off, or (with --project) inherit");
+    if (value3 === void 0)
+      throw new CliError("--auto-publish takes on, off, or (with --project) inherit");
     if (options.project) {
       ensureConfig(projectFile);
       setProjectAutoPublish(projectFile, value3);
@@ -2386,7 +2715,7 @@ var configCommand = {
       value: "on|off|inherit",
       help: "Turn auto-publish on or off; inherit (with --project) drops the override"
     },
-    project: { type: "boolean", help: "Set it for this project only instead of every project" }
+    "project": { type: "boolean", help: "Set it for this project only instead of every project" }
   },
   semantic: (input) => bindCommand(
     {
@@ -2400,7 +2729,11 @@ var configCommand = {
         if (input.values["auto-publish"] !== void 0 && input.values["output-format"] !== void 0)
           throw new CliError("Choose auto-publish or output-format.");
         if (typeof input.values["output-format"] === "string")
-          writeOutputFormat(input.projectDir, !!input.values.project, input.values["output-format"]);
+          writeOutputFormat(
+            input.projectDir,
+            !!input.values.project,
+            input.values["output-format"]
+          );
         const values = configure({
           projectDir: input.projectDir,
           autoPublish: input.values["auto-publish"],
@@ -2414,24 +2747,29 @@ var configCommand = {
           applies: "supported_turn_end_hook"
         });
       },
-      present({ data }) {
-        return {
-          heading: input.values["output-format"] !== void 0 ? "Output" : "Auto-publish",
-          status: data.effective === null ? "undecided" : data.effective ? "on" : "off",
-          facts: [
-            fact("Output", field(data, "output"), true),
-            fact("Source", field(data, "source"), true),
-            fact("Global", field(data, "global")),
-            fact("Project", field(data, "project")),
-            fact("Applies", field(data, "applies"))
-          ],
-          sections: []
-        };
-      }
+      present: presentConfig
     },
     input
   )
 };
+function presentConfig({ data }) {
+  const on = data.effective === null ? "undecided" : data.effective ? "on" : "off";
+  return {
+    heading: "Config",
+    status: "",
+    facts: [
+      fact("Auto-publish", {
+        key: "autoPublish",
+        value: data.source === "undecided" ? on : `${on} (${data.source})`
+      }),
+      fact("Output format", {
+        key: "output",
+        value: `${data.output.effective} (${data.output.source})`
+      })
+    ],
+    sections: []
+  };
+}
 
 // src/cli/semantic/get.ts
 var import_node_fs11 = __toESM(require("node:fs"), 1);
@@ -2458,6 +2796,39 @@ function stripRuntime(html) {
 }
 
 // src/cli/semantic/get.ts
+function presentGet({ data }) {
+  return {
+    heading: "Cloud artifact",
+    status: data.status === "downloaded" || data.status === "partial" ? data.status : "",
+    subject: data.id,
+    summary: [data.type, `v${data.version}`, data.visibility].join(" \xB7 "),
+    facts: [
+      fact("Title", field(data, "title")),
+      ...data.dir ? [fact("Downloaded", field(data, "dir"), true)] : data.files ? [fact("Files available", { key: "files", value: data.files.join(", ") })] : []
+    ],
+    sections: [
+      ...data.outline ? [
+        {
+          kind: "records",
+          key: "outline",
+          rows: data.outline,
+          columns: [
+            { key: "id", positional: true, required: true },
+            { key: "type", positional: true },
+            { key: "preview", positional: true }
+          ]
+        }
+      ] : [],
+      ...data.content !== void 0 ? [{ kind: "content", key: "content", title: "LiteXML", text: data.content }] : [],
+      ...data.comments ? [
+        {
+          ...threadMessages(data.comments.threads, "comments"),
+          title: "Published snapshot comments"
+        }
+      ] : []
+    ]
+  };
+}
 var value2 = (input, key) => typeof input.values[key] === "string" ? input.values[key] : void 0;
 var safePath = (file) => !!file && !file.includes("\\") && !file.includes("\0") && !import_node_path10.default.posix.isAbsolute(file) && file.split("/").every((p) => !!p && p !== "." && p !== "..");
 async function downloadFiles(data, dir, ctx) {
@@ -2512,7 +2883,7 @@ function getSemantic(input) {
       code: "E_ARGUMENT_INVALID",
       message: "Give a Cloud link or artifact ID."
     });
-  const { origin, id } = parseTarget(
+  const { origin, id: id2 } = parseTarget(
     target,
     (process.env.RYUGI_CLOUD_ORIGIN || "https://ryugi.innei.dev").replace(/\/+$/, "")
   );
@@ -2579,7 +2950,7 @@ function getSemantic(input) {
           credentialsFile(process.env, process.platform, import_node_os5.default.homedir()),
           origin
         );
-        const response = await fetch(`${origin}/api/a/${id}?${query2}`, {
+        const response = await fetch(`${origin}/api/a/${id2}?${query2}`, {
           headers: credentials ? { Authorization: `Bearer ${credentials.token}` } : {},
           signal: ctx.signal
         });
@@ -2629,7 +3000,7 @@ function getSemantic(input) {
               process.env.XDG_CACHE_HOME || import_node_path10.default.join(import_node_os5.default.homedir(), ".cache"),
               "ryugi",
               "get",
-              id,
+              id2,
               `v${data.version}`
             )
           );
@@ -2670,43 +3041,7 @@ function getSemantic(input) {
           ]
         });
       },
-      present({ data }) {
-        return {
-          heading: "Cloud artifact",
-          status: data.status,
-          subject: data.id,
-          facts: [
-            fact("Type", field(data, "type"), true),
-            fact("Title", field(data, "title")),
-            fact("Version", field(data, "version"), true),
-            fact("Visibility", field(data, "visibility"), true),
-            ...data.dir ? [fact("Downloaded", field(data, "dir"), true)] : data.files ? [fact("Files available", field(data, "files"))] : []
-          ],
-          sections: [
-            ...data.outline ? [
-              {
-                kind: "records",
-                key: "outline",
-                rows: data.outline,
-                columns: [
-                  { key: "id", label: "ID", required: true },
-                  { key: "type", label: "Type" },
-                  { key: "preview", label: "Preview" }
-                ]
-              }
-            ] : [],
-            ...data.content !== void 0 ? [{ kind: "content", key: "content", title: "LiteXML", text: data.content }] : [],
-            ...data.comments ? [
-              {
-                kind: "content",
-                key: "comments",
-                title: "Published snapshot comments",
-                text: JSON.stringify(data.comments.threads)
-              }
-            ] : []
-          ]
-        };
-      }
+      present: presentGet
     },
     input
   );
@@ -2724,10 +3059,10 @@ function parseTarget(target, defaultOrigin) {
   } catch {
     throw new CliError(TARGET_ERROR);
   }
-  const id = LINK_PATH.exec(url.pathname)?.[1];
-  if (!id || url.protocol !== "https:" && url.protocol !== "http:")
+  const id2 = LINK_PATH.exec(url.pathname)?.[1];
+  if (!id2 || url.protocol !== "https:" && url.protocol !== "http:")
     throw new CliError(TARGET_ERROR);
-  return { origin: url.origin, id };
+  return { origin: url.origin, id: id2 };
 }
 var getCommand = {
   name: "get",
@@ -2781,6 +3116,74 @@ function acceptCloud(response) {
 }
 
 // src/cli/semantic/publish.ts
+function presentPublish({ data }) {
+  return {
+    heading: "Publish",
+    status: data.status,
+    subject: data.artifact,
+    facts: [
+      fact("ID", field(data, "id"), true),
+      fact("URL", field(data, "url"), true),
+      fact(
+        "Visibility",
+        { key: "visibility", value: `${data.visibility} (${data.visibilitySource})` },
+        true
+      ),
+      ...data.version === void 0 ? [] : [fact("Version", field(data, "version"))],
+      fact("Unpublished references", { key: "unpublished", value: data.unpublished.join(", ") }),
+      fact("Private references", { key: "private", value: data.private.join(", ") })
+    ],
+    sections: data.references.length ? [
+      {
+        kind: "records",
+        key: "references",
+        title: "Referenced artifacts",
+        rows: data.references.map((ref) => ({
+          artifact: ref.artifact,
+          status: ref.status,
+          error: ref.error ? `${ref.error.code}: ${ref.error.message}` : "",
+          recovery: ref.status === "unknown" ? "inspect the remote artifact before retrying" : ""
+        })),
+        columns: [
+          { key: "artifact", positional: true, required: true },
+          { key: "status", positional: true, required: true },
+          { key: "error", positional: true },
+          { key: "recovery", positional: true }
+        ]
+      }
+    ] : []
+  };
+}
+function presentCloudList({
+  data,
+  coverage
+}) {
+  const total = coverage.page?.total ?? data.artifacts.length;
+  return {
+    heading: "Cloud artifacts",
+    status: "",
+    summary: `${total} on account`,
+    facts: [],
+    sections: [
+      {
+        kind: "records",
+        key: "artifacts",
+        rows: data.artifacts.map((row) => ({
+          ...row,
+          version: row.version === void 0 ? "" : `v${row.version}`
+        })),
+        columns: [
+          { key: "id", positional: true, required: true },
+          { key: "type", positional: true },
+          { key: "visibility", positional: true, required: true },
+          { key: "version", positional: true },
+          { key: "updatedAt", positional: true },
+          { key: "title", positional: true }
+        ]
+      }
+    ]
+  };
+}
 var formats2 = ["brief", "json", "jsonl", "quiet"];
 function optionsOf(input) {
   const { values } = input;
@@ -2841,8 +3244,8 @@ async function publishReport(input, ctx, artifact, visibility) {
   const published = await send(artifact, visibility);
   const boards = published.boards;
   const pending = [...boards?.unpublished ?? []];
-  const references = (boards?.published ?? []).map((id) => ({
-    artifact: `artboard/${id}`,
+  const references = (boards?.published ?? []).map((id2) => ({
+    artifact: `artboard/${id2}`,
     status: "published"
   }));
   let partial = false;
@@ -2858,10 +3261,10 @@ async function publishReport(input, ctx, artifact, visibility) {
           status: errorOf(error).httpStatus && errorOf(error).httpStatus < 500 ? "failed" : "unknown",
           error: errorOf(error)
         });
-        for (const id of pending.slice(i + 1)) {
-          const effect = ctx.effects.begin("publish", `artboard/${id}`);
+        for (const id2 of pending.slice(i + 1)) {
+          const effect = ctx.effects.begin("publish", `artboard/${id2}`);
           ctx.effects.set(effect, "not_attempted");
-          references.push({ artifact: `artboard/${id}`, status: "not_attempted" });
+          references.push({ artifact: `artboard/${id2}`, status: "not_attempted" });
         }
         partial = true;
         break;
@@ -2880,7 +3283,7 @@ async function publishReport(input, ctx, artifact, visibility) {
     ...published.version === void 0 ? {} : { version: published.version },
     visibilitySource: visibility ? "requested" : "preserved",
     references,
-    unpublished: pending.filter((id) => !succeeded.has(`artboard/${id}`)),
+    unpublished: pending.filter((id2) => !succeeded.has(`artboard/${id2}`)),
     private: boards?.private ?? []
   };
   return result(report2, partial ? { kind: "partial" } : { kind: "succeeded" }, {
@@ -2918,41 +3321,7 @@ function publishSemantic(input) {
         mode: "finite",
         output: { formats: formats2, scalar: (data) => data.id },
         run: (_input, ctx) => publishReport(input, ctx, artifact, visibility),
-        present({ data }) {
-          return {
-            heading: "Publish",
-            status: data.status,
-            subject: data.artifact,
-            facts: [
-              fact("ID", field(data, "id"), true),
-              fact("URL", field(data, "url"), true),
-              fact("Visibility", field(data, "visibility"), true),
-              fact("Visibility source", field(data, "visibilitySource")),
-              ...data.version === void 0 ? [] : [fact("Version", field(data, "version"))],
-              ...data.unpublished.length ? [fact("Unpublished references", field(data, "unpublished"))] : [],
-              ...data.private.length ? [fact("Private references", field(data, "private"))] : []
-            ],
-            sections: data.references.length ? [
-              {
-                kind: "records",
-                key: "references",
-                title: "Referenced artifacts",
-                rows: data.references.map((ref) => ({
-                  artifact: ref.artifact,
-                  status: ref.status,
-                  error: ref.error ? `${ref.error.code}: ${ref.error.message}` : "",
-                  recovery: ref.status === "unknown" ? "Inspect the remote artifact before retrying" : ""
-                })),
-                columns: [
-                  { key: "artifact", label: "Artifact", required: true },
-                  { key: "status", label: "Status", required: true },
-                  { key: "error", label: "Reason" },
-                  { key: "recovery", label: "Recovery" }
-                ]
-              }
-            ] : []
-          };
-        }
+        present: presentPublish
       },
       input
     );
@@ -3012,27 +3381,7 @@ function publishSemantic(input) {
             ] : []
           });
         },
-        present({ data }) {
-          return {
-            heading: "Cloud artifacts",
-            status: "listed",
-            facts: [],
-            sections: [
-              {
-                kind: "records",
-                key: "artifacts",
-                rows: data.artifacts.map((row) => ({ ...row })),
-                columns: [
-                  { key: "id", label: "ID", required: true },
-                  { key: "type", label: "Type" },
-                  { key: "title", label: "Title" },
-                  { key: "visibility", label: "Visibility", required: true },
-                  { key: "updatedAt", label: "Updated" }
-                ]
-              }
-            ]
-          };
-        }
+        present: presentCloudList
       },
       input
     );
@@ -3228,26 +3577,27 @@ var sceneCommand = {
           }
         );
       },
-      present({ data }) {
-        return {
-          heading: "Scene",
-          status: data.problem ? "invalid" : "read",
-          subject: data.artifact,
-          facts: [
-            ...data.page ? [fact("Page", field(data, "page"))] : [],
-            fact("Version", field(data, "sceneVersion")),
-            fact("Render", field(data, "render")),
-            ...data.renderPath ? [fact("Image", field(data, "renderPath"))] : [],
-            ...data.problem ? [fact("Problem", field(data, "problem"))] : [],
-            ...data.conflicts.length ? [fact("Conflicts", field(data, "conflicts"))] : []
-          ],
-          sections: [{ kind: "content", key: "lines", text: data.lines.join("\n") }]
-        };
-      }
+      present: presentScene
     },
     input
   )
 };
+function presentScene({ data }) {
+  return {
+    heading: "Scene",
+    status: data.problem ? "invalid" : "",
+    subject: data.artifact,
+    facts: [
+      ...data.page ? [fact("Page", field(data, "page"))] : [],
+      fact("Version", field(data, "sceneVersion")),
+      fact("Render", field(data, "render")),
+      ...data.renderPath ? [fact("Image", field(data, "renderPath"))] : [],
+      ...data.problem ? [fact("Problem", field(data, "problem"))] : [],
+      fact("Conflicts", { key: "conflicts", value: data.conflicts.join(", ") })
+    ],
+    sections: [{ kind: "content", key: "lines", text: data.lines.join("\n") }]
+  };
+}
 
 // src/cli/start.ts
 var import_node_child_process3 = require("node:child_process");
@@ -3271,48 +3621,48 @@ var MINT_LENGTH = 21;
 var MINTED_PATTERN = new RegExp(`^[a-z0-9]{${MINT_LENGTH}}$`, "i");
 var MINT_BYTE_LIMIT = 248;
 function mintArtifactId() {
-  let id = "";
+  let id2 = "";
   const bytes = new Uint8Array(MINT_LENGTH * 2);
-  while (id.length < MINT_LENGTH) {
+  while (id2.length < MINT_LENGTH) {
     crypto.getRandomValues(bytes);
     for (const byte of bytes) {
       if (byte >= MINT_BYTE_LIMIT) continue;
-      id += MINT_ALPHABET[byte % MINT_ALPHABET.length];
-      if (id.length === MINT_LENGTH) break;
+      id2 += MINT_ALPHABET[byte % MINT_ALPHABET.length];
+      if (id2.length === MINT_LENGTH) break;
     }
   }
-  return id;
+  return id2;
 }
-var isArtifactId = (id) => ID_PATTERN.test(id);
-var isArtifactAddress = (id) => ADDRESS_PATTERN.test(id);
+var isArtifactId = (id2) => ID_PATTERN.test(id2);
+var isArtifactAddress = (id2) => ADDRESS_PATTERN.test(id2);
 var isArtifactType = (type) => ARTIFACT_TYPES.includes(type);
 
 // src/server/artifacts.ts
 function artifactKeyOf(relative, isId = isArtifactId) {
-  const [type, id] = relative.split("/");
-  if (!type || !id || !isArtifactType(type) || !isId(id)) return null;
-  return { type, id };
+  const [type, id2] = relative.split("/");
+  if (!type || !id2 || !isArtifactType(type) || !isId(id2)) return null;
+  return { type, id: id2 };
 }
 
 // src/server/artifact-address.ts
 function artifactId(dir) {
   const file = import_node_path11.default.join(dir, ".artifact-id");
-  let id;
+  let id2;
   try {
-    id = import_node_fs12.default.readFileSync(file, "utf8").trim();
+    id2 = import_node_fs12.default.readFileSync(file, "utf8").trim();
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
-    id = mintArtifactId();
+    id2 = mintArtifactId();
     try {
-      import_node_fs12.default.writeFileSync(file, `${id}
+      import_node_fs12.default.writeFileSync(file, `${id2}
 `, { flag: "wx" });
     } catch (writeError) {
       if (writeError.code !== "EEXIST") throw writeError;
       return artifactId(dir);
     }
   }
-  if (!isArtifactAddress(id)) throw new Error(`Invalid artifact ID in ${file}`);
-  return id;
+  if (!isArtifactAddress(id2)) throw new Error(`Invalid artifact ID in ${file}`);
+  return id2;
 }
 function artifactPath(root, type, slug) {
   if (!isArtifactType(type) || !isArtifactId(slug)) throw new Error("Invalid artifact locator");
@@ -3507,13 +3857,12 @@ function report(options, info) {
     cloud: info?.cloudLink ? "live_link_reserved" : "local_only"
   };
 }
-function present({ data }) {
+function presentServer({ data }) {
   return {
     heading: "Server",
     status: data.status,
     subject: data.reused ? "reused" : void 0,
     facts: [
-      fact("Scope", field(data, "scope"), true),
       fact("Project", field(data, "project"), true),
       ...data.artifact ? [fact("Artifact", field(data, "artifact"), true)] : [],
       ...data.url ? [fact("Open", field(data, "url"), true)] : [],
@@ -3566,7 +3915,7 @@ async function* lifecycle(options, ctx) {
     failure(value3) {
       startupError = String(value3.error ?? "Server failed");
     },
-    log: (text) => ctx.diagnostic(text)
+    log: (text2) => ctx.diagnostic(text2)
   }).then((code) => {
     if (ctx.signal.aborted) {
       const signal = ctx.signal.reason === "SIGINT" ? "SIGINT" : "SIGTERM";
@@ -3624,7 +3973,7 @@ function startSemantic(input, operation = "start") {
         mode: "live",
         output: { formats: ["brief", "jsonl"] },
         run: (_input, ctx) => lifecycle(options, ctx),
-        present
+        present: presentServer
       },
       input
     );
@@ -3646,7 +3995,7 @@ function startSemantic(input, operation = "start") {
           failure(error) {
             failure = String(error.error ?? "Server failed");
           },
-          log: (text) => ctx.diagnostic(text)
+          log: (text2) => ctx.diagnostic(text2)
         });
         if (code !== 0 || !value3)
           throw new OutputError({
@@ -3655,7 +4004,7 @@ function startSemantic(input, operation = "start") {
           });
         return started(options, value3);
       },
-      present
+      present: presentServer
     },
     input
   );
@@ -3738,9 +4087,9 @@ async function acquireLock(lock) {
 }
 function runningPid(machine) {
   const pid = Number(readText(machine.pid));
-  const id = readText(machine.serverId);
-  if (!Number.isInteger(pid) || pid <= 0 || !id) return null;
-  return hasServerId(pid, id) ? pid : null;
+  const id2 = readText(machine.serverId);
+  if (!Number.isInteger(pid) || pid <= 0 || !id2) return null;
+  return hasServerId(pid, id2) ? pid : null;
 }
 function readInfo(machine) {
   try {
@@ -3813,8 +4162,8 @@ function serverEnv(options) {
     delete env[key];
   return env;
 }
-var startedLine = (text) => text.split("\n").find((line) => line.includes('"server-started"'));
-var errorLine = (text) => text.split("\n").find((line) => line.includes('"server-error"'));
+var startedLine = (text2) => text2.split("\n").find((line2) => line2.includes('"server-started"'));
+var errorLine = (text2) => text2.split("\n").find((line2) => line2.includes('"server-error"'));
 async function register(info, paths, open) {
   const res = await fetch(apiUrl(info, "/api/hub/projects"), {
     method: "POST",
@@ -3841,7 +4190,7 @@ async function startServer(options, hooks) {
   import_node_fs15.default.mkdirSync(paths.state, { recursive: true });
   if (!import_node_fs15.default.existsSync(import_node_path15.default.join(paths.state, ".gitignore")))
     import_node_fs15.default.writeFileSync(import_node_path15.default.join(paths.state, ".gitignore"), "*\n");
-  const cliVersion = process.env.RYUGI_ARTIFACTS_VERSION || (true ? "1.63.0" : "");
+  const cliVersion = process.env.RYUGI_ARTIFACTS_VERSION || (true ? "1.65.0" : "");
   const known = readProjects(machine.projects).some((entry) => entry.dir === paths.project);
   const finish = async (info, reused) => {
     recordAgent(paths);
@@ -3900,13 +4249,13 @@ async function startServer(options, hooks) {
     }
     await stopOldProjectServers();
     import_node_fs15.default.rmSync(machine.info, { force: true });
-    const id = import_node_crypto2.default.randomBytes(24).toString("hex");
-    import_node_fs15.default.writeFileSync(machine.serverId, `${id}
+    const id2 = import_node_crypto2.default.randomBytes(24).toString("hex");
+    import_node_fs15.default.writeFileSync(machine.serverId, `${id2}
 `);
     import_node_fs15.default.writeFileSync(machine.version, `${cliVersion}
 `);
     const server = import_node_path15.default.join(__dirname, "server.cjs");
-    const args = [server, `--artifacts-server-id=${id}`, ...options.port ? [`--port=${options.port}`] : []];
+    const args = [server, `--artifacts-server-id=${id2}`, ...options.port ? [`--port=${options.port}`] : []];
     const env = serverEnv(options);
     const foreground = options.foreground || !options.background && !!process.env.CODEX_CI;
     if (foreground) {
@@ -3918,16 +4267,16 @@ async function startServer(options, hooks) {
       };
       if (hooks.signal) hooks.signal.addEventListener("abort", terminate, { once: true });
       else for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, terminate);
-      import_node_readline.default.createInterface({ input: child2.stderr }).on("line", (line) => hooks.log(line, "stderr"));
+      import_node_readline.default.createInterface({ input: child2.stderr }).on("line", (line2) => hooks.log(line2, "stderr"));
       const exited = new Promise((resolve) => child2.on("close", (code) => resolve(code ?? 1)));
       let announced = false;
       let startup;
-      import_node_readline.default.createInterface({ input: child2.stdout }).on("line", (line) => {
+      import_node_readline.default.createInterface({ input: child2.stdout }).on("line", (line2) => {
         let value3;
         try {
-          value3 = JSON.parse(line);
+          value3 = JSON.parse(line2);
         } catch {
-          hooks.log(line, "stdout");
+          hooks.log(line2, "stdout");
           return;
         }
         if (value3.type !== "server-started" || announced) {
@@ -3966,8 +4315,8 @@ async function startServer(options, hooks) {
     import_node_fs15.default.writeFileSync(machine.pid, `${child.pid}
 `);
     for (let waited = 0; waited < START_TIMEOUT_MS; waited += 100) {
-      const text = readText(machine.log) ?? "";
-      const started2 = startedLine(text);
+      const text2 = readText(machine.log) ?? "";
+      const started2 = startedLine(text2);
       if (started2) {
         for (let check = 0; check < 10; check++) {
           if (!alive(child.pid))
@@ -3980,7 +4329,7 @@ async function startServer(options, hooks) {
         await finish(JSON.parse(started2), false);
         return 0;
       }
-      const failed = errorLine(text);
+      const failed = errorLine(text2);
       if (failed) {
         hooks.failure(JSON.parse(failed));
         return 1;
@@ -4037,6 +4386,15 @@ function clearCompatInfo(projectsFile) {
   for (const entry of readProjects(projectsFile))
     import_node_fs16.default.rmSync(import_node_path16.default.join(artifactsRootOf(entry.dir), ".state", "server-info"), { force: true });
 }
+function presentStop({ data }) {
+  return {
+    heading: "Server",
+    status: data.status,
+    summary: data.status === data.reason ? "" : data.reason.replaceAll("_", " "),
+    facts: [fact("Artifacts", field(data, "artifacts"))],
+    sections: []
+  };
+}
 async function stopServer() {
   const machine = machinePaths();
   const markStopped = (reason) => {
@@ -4053,8 +4411,8 @@ async function stopServer() {
     return { status: "not_running" };
   }
   const pid = Number(readText(machine.pid));
-  const id = readText(machine.serverId) ?? "";
-  if (!Number.isInteger(pid) || pid <= 0 || !/^[\w-]{32,64}$/.test(id) || !hasServerId(pid, id)) {
+  const id2 = readText(machine.serverId) ?? "";
+  if (!Number.isInteger(pid) || pid <= 0 || !/^[\w-]{32,64}$/.test(id2) || !hasServerId(pid, id2)) {
     import_node_fs16.default.rmSync(machine.pid, { force: true });
     import_node_fs16.default.rmSync(machine.serverId, { force: true });
     markStopped("stale_pid");
@@ -4100,18 +4458,7 @@ var stopCommand = {
           state.status === "failed" ? { kind: "failed", error: { code: "E_SERVER_STOP_FAILED", message: state.error } } : { kind: "succeeded" }
         );
       },
-      present({ data }) {
-        return {
-          heading: "Server",
-          status: data.status,
-          facts: [
-            fact("Scope", field(data, "scope"), true),
-            fact("Reason", field(data, "reason")),
-            fact("Artifacts", field(data, "artifacts"))
-          ],
-          sections: []
-        };
-      }
+      present: presentStop
     },
     input
   )
@@ -4185,7 +4532,9 @@ async function fetchLatest(registry) {
     if (res.ok && typeof version === "string" && /^\d+\.\d+\.\d+/.test(version)) return version;
     throw new Error(`registry returned ${res.status}`);
   } catch (err) {
-    throw new CliError(`Could not get the latest ${PACKAGE} version from ${base}: ${err.message}`);
+    throw new CliError(
+      `Could not get the latest ${PACKAGE} version from ${base}: ${err.message}`
+    );
   }
 }
 function advice(install, latest) {
@@ -4235,8 +4584,10 @@ or run \`${PACKAGE} update --pm <${PMS.join("|")}>\`.`
   const result2 = windows ? (0, import_node_child_process4.spawnSync)(commandLine2(command), { stdio: [...stdio], env: options.env, shell: true }) : (0, import_node_child_process4.spawnSync)(command.cmd, command.args, { stdio: [...stdio], env: options.env });
   if (result2.stdout?.length) hooks.log?.(result2.stdout.toString());
   if (result2.stderr?.length) hooks.log?.(result2.stderr.toString());
-  if (result2.error) throw new CliError(`Could not run ${commandLine2(command)}: ${result2.error.message}`);
-  if (result2.status !== 0) throw new CliError(`${commandLine2(command)} exited with ${result2.status ?? result2.signal}`);
+  if (result2.error)
+    throw new CliError(`Could not run ${commandLine2(command)}: ${result2.error.message}`);
+  if (result2.status !== 0)
+    throw new CliError(`${commandLine2(command)} exited with ${result2.status ?? result2.signal}`);
   return {
     type: "updated",
     from: options.current,
@@ -4270,7 +4621,7 @@ var updateCommand = {
         try {
           report2 = await performUpdate(
             {
-              current: "1.63.0",
+              current: "1.65.0",
               file: __filename,
               env: process.env,
               registry: process.env.npm_config_registry || "https://registry.npmjs.org/",
@@ -4286,7 +4637,10 @@ var updateCommand = {
           );
         } catch (error) {
           if (error instanceof InstallUnknownError)
-            throw new OutputError({ code: "E_INSTALL_UNKNOWN", message: error.message }, "action_required");
+            throw new OutputError(
+              { code: "E_INSTALL_UNKNOWN", message: error.message },
+              "action_required"
+            );
           throw error;
         }
         if (report2.type === "updated" && effect !== void 0)
@@ -4309,24 +4663,26 @@ var updateCommand = {
         };
         return result(data, void 0, { effects: ctx.effects.snapshot() });
       },
-      present({ data }) {
-        return {
-          heading: "Update",
-          status: data.status,
-          facts: [
-            fact("Current", field(data, "current"), true),
-            fact("Latest", field(data, "latest")),
-            fact("Install", field(data, "install")),
-            fact("Installed", field(data, "installed")),
-            ...data.message ? [fact("Advice", field(data, "message"))] : []
-          ],
-          sections: []
-        };
-      }
+      present: presentUpdate
     },
     input
   )
 };
+function presentUpdate({
+  data
+}) {
+  return {
+    heading: "Update",
+    status: data.status,
+    facts: [
+      fact("Current", field(data, "current"), true),
+      fact("Latest", field(data, "latest")),
+      fact("Install", field(data, "install")),
+      ...data.message ? [fact("Advice", field(data, "message"))] : []
+    ],
+    sections: []
+  };
+}
 
 // src/cli/commands.ts
 var COMMANDS = [
@@ -4379,9 +4735,9 @@ async function semanticFailure(command, error, options, writer) {
     writer
   );
 }
-function textDefinition(id, data) {
+function textDefinition(id2, data) {
   return {
-    id,
+    id: id2,
     mode: "finite",
     output: {
       formats: ["brief", "json", "jsonl"],
@@ -4391,11 +4747,11 @@ function textDefinition(id, data) {
       return result(data);
     },
     present({ data: data2 }) {
-      return {
-        heading: id === "version" ? "Version" : "Help",
-        status: "ready",
-        facts: data2.version ? [fact("Version", field(data2, "version"), true)] : [],
-        sections: data2.version ? [] : [{ kind: "content", key: "text", text: data2.text }]
+      return data2.version ? { heading: `ryugi-artifacts ${data2.version}`, status: "", facts: [], sections: [] } : {
+        heading: "Help",
+        status: "",
+        facts: [],
+        sections: [{ kind: "content", key: "text", text: data2.text }]
       };
     }
   };
@@ -4413,10 +4769,10 @@ async function dispatchSemantic(argv, commands, browseOptions, version, options,
     }
     if (name === "--help" || name === "-h" || command && wantsHelp(rest)) {
       if (!command) parse(rest, {}, 0);
-      const text = command ? commandHelp(command) : rootHelp(commands, browseOptions);
+      const text2 = command ? commandHelp(command) : rootHelp(commands, browseOptions);
       return await bindCommand(
         textDefinition("help", {
-          text,
+          text: text2,
           commands: commands.map(({ name: name2, summary }) => ({ name: name2, summary }))
         }),
         void 0
@@ -4474,7 +4830,7 @@ async function main(argv) {
   process.on("SIGINT", interrupt);
   process.on("SIGTERM", terminate);
   try {
-    return await dispatchSemantic(argv, COMMANDS, BROWSE_OPTIONS, "1.63.0", selection.options, writer, abort.signal);
+    return await dispatchSemantic(argv, COMMANDS, BROWSE_OPTIONS, "1.65.0", selection.options, writer, abort.signal);
   } finally {
     process.removeListener("SIGINT", interrupt);
     process.removeListener("SIGTERM", terminate);