@united-workforce/cli 0.4.0 → 0.6.0

package/src/output-mappers.ts

@@ -0,0 +1,255 @@
+import type { CasRef, StartOutput, StepOutput } from "@united-workforce/protocol";
+import { extractUlidTimestamp } from "@united-workforce/util";
+import type { ThreadListItemWithStatus } from "./commands/thread.js";
+import type {
+  WorkflowAddOutput,
+  WorkflowListEntry,
+  WorkflowShowOutput,
+} from "./commands/workflow.js";
+
+/**
+ * Mappers that convert the existing rich command outputs into the
+ * schema-aligned payload shapes registered under `@uwf/output/*`.
+ *
+ * Each mapper returns plain payload data — no CAS refs, no JSON encoding,
+ * no I/O. The CLI calls one of these immediately before handing the payload
+ * to `writeEnvelope`.
+ */
+
+export type ThreadStartPayload = {
+  threadId: string;
+  workflowHash: string;
+};
+
+export function toThreadStartPayload(out: StartOutput): ThreadStartPayload {
+  return { threadId: out.thread, workflowHash: out.workflow };
+}
+
+export type ThreadStatusPayload = {
+  threadId: string;
+  workflowHash: string;
+  head: string | null;
+  status: string;
+  currentRole: string | null;
+  suspendedRole: string | null;
+  suspendMessage: string | null;
+  done: boolean;
+};
+
+export function toThreadStatusPayload(out: StepOutput): ThreadStatusPayload {
+  return {
+    threadId: out.thread,
+    workflowHash: out.workflow,
+    head: out.head ?? null,
+    status: out.status,
+    currentRole: out.currentRole,
+    suspendedRole: out.suspendedRole,
+    suspendMessage: out.suspendMessage,
+    done: out.done,
+  };
+}
+
+export type ThreadListPayload = {
+  items: Array<{
+    threadId: string;
+    workflowHash: string;
+    workflowName: string | null;
+    status: string;
+    currentRole: string | null;
+    startedAt: number | null;
+    completedAt: number | null;
+  }>;
+};
+
+export function toThreadListPayload(items: ThreadListItemWithStatus[]): ThreadListPayload {
+  return {
+    items: items.map((it) => ({
+      threadId: it.thread,
+      workflowHash: it.workflow,
+      workflowName: it.workflowName,
+      status: it.status,
+      currentRole: it.currentRole,
+      startedAt: extractUlidTimestamp(it.thread),
+      completedAt: null,
+    })),
+  };
+}
+
+export type ThreadExecPayload = {
+  threadId: string;
+  workflowHash: string;
+  steps: Array<{
+    head: string;
+    status: string;
+    currentRole: string | null;
+    done: boolean;
+    role: string | null;
+    suspendedRole: string | null;
+    suspendMessage: string | null;
+  }>;
+};
+
+export function toThreadExecPayload(results: StepOutput[]): ThreadExecPayload {
+  const first = results[0];
+  return {
+    threadId: first?.thread ?? "",
+    workflowHash: first?.workflow ?? "",
+    steps: results.map((r) => ({
+      head: r.head,
+      status: r.status,
+      currentRole: r.currentRole,
+      done: r.done,
+      role: r.currentRole ?? r.suspendedRole ?? null,
+      suspendedRole: r.suspendedRole,
+      suspendMessage: r.suspendMessage,
+    })),
+  };
+}
+
+export type StepDetailPayload = {
+  hash: string;
+  role: string;
+  agent: string;
+  status: string;
+  startedAtMs: number | null;
+  completedAtMs: number | null;
+  durationMs: number | null;
+  frontmatter: Record<string, unknown>;
+  turns: Array<{ role: string; content: string; timestamp: number | null }>;
+};
+
+export function toStepDetailPayload(stepHash: CasRef, raw: unknown): StepDetailPayload {
+  const r = (raw ?? {}) as Record<string, unknown>;
+  const turnsIn = Array.isArray(r.turns) ? (r.turns as unknown[]) : [];
+  const startedAtMs = numericOrNull(r.startedAtMs);
+  const completedAtMs = numericOrNull(r.completedAtMs);
+  const durationMs =
+    startedAtMs !== null && completedAtMs !== null && completedAtMs >= startedAtMs
+      ? completedAtMs - startedAtMs
+      : null;
+  const frontmatter =
+    r.frontmatter !== null && typeof r.frontmatter === "object" && !Array.isArray(r.frontmatter)
+      ? (r.frontmatter as Record<string, unknown>)
+      : {};
+  const status =
+    typeof frontmatter.$status === "string"
+      ? (frontmatter.$status as string)
+      : typeof r.status === "string"
+        ? (r.status as string)
+        : "";
+  return {
+    hash: stepHash,
+    role: typeof r.role === "string" ? r.role : "",
+    agent: typeof r.agent === "string" ? r.agent : "",
+    status,
+    startedAtMs,
+    completedAtMs,
+    durationMs,
+    frontmatter,
+    turns: turnsIn.map((t) => {
+      const o = (t ?? {}) as Record<string, unknown>;
+      return {
+        role: typeof o.role === "string" ? o.role : "",
+        content: typeof o.content === "string" ? o.content : "",
+        timestamp: numericOrNull(o.timestamp),
+      };
+    }),
+  };
+}
+
+function numericOrNull(v: unknown): number | null {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+
+export type StepListPayload = {
+  threadId: string;
+  items: Array<{ hash: string; role: string; durationMs: number | null }>;
+};
+
+type StepsLikeOutput = {
+  thread: string;
+  steps: Array<{
+    hash: CasRef;
+    role?: string;
+    durationMs?: number;
+  }>;
+};
+
+export function toStepListPayload(out: StepsLikeOutput): StepListPayload {
+  return {
+    threadId: out.thread,
+    items: out.steps
+      .filter((s) => typeof s.role === "string")
+      .map((s) => ({
+        hash: s.hash,
+        role: s.role ?? "",
+        durationMs: typeof s.durationMs === "number" ? s.durationMs : null,
+      })),
+  };
+}
+
+export type WorkflowDetailPayload = {
+  name: string;
+  hash: string;
+  version: number;
+  description: string;
+  roles: Record<string, { description: string; goal: string }>;
+  graph: Record<string, Record<string, { role: string; prompt: string }>>;
+};
+
+export function toWorkflowDetailPayload(out: WorkflowShowOutput): WorkflowDetailPayload {
+  const roles: Record<string, { description: string; goal: string }> = {};
+  for (const [name, def] of Object.entries(out.payload.roles)) {
+    roles[name] = { description: def.description, goal: def.goal };
+  }
+  const graph: Record<string, Record<string, { role: string; prompt: string }>> = {};
+  for (const [from, transitions] of Object.entries(out.payload.graph)) {
+    const t: Record<string, { role: string; prompt: string }> = {};
+    for (const [status, target] of Object.entries(transitions)) {
+      t[status] = { role: target.role, prompt: target.prompt };
+    }
+    graph[from] = t;
+  }
+  return {
+    name: out.name ?? out.payload.name,
+    hash: out.hash,
+    version: out.payload.version,
+    description: out.payload.description,
+    roles,
+    graph,
+  };
+}
+
+export type WorkflowListPayload = {
+  items: Array<{ name: string; hash: string; source: string; description: string }>;
+};
+
+export function toWorkflowListPayload(entries: WorkflowListEntry[]): WorkflowListPayload {
+  return {
+    items: entries.map((e) => ({
+      name: e.name,
+      hash: e.hash,
+      source:
+        e.origin === "local" ? ".workflows" : e.origin === "paths" ? "workflowPaths" : "registry",
+      description: "",
+    })),
+  };
+}
+
+export type WorkflowAddPayload = {
+  name: string;
+  hash: string;
+};
+
+export function toWorkflowAddPayload(out: WorkflowAddOutput): WorkflowAddPayload {
+  return { name: out.name, hash: out.hash };
+}
+
+export type ValidateResultPayload = {
+  valid: boolean;
+  errors: string[];
+};
+
+export function toValidateResultPayload(errors: string[]): ValidateResultPayload {
+  return { valid: errors.length === 0, errors };
+}

package/src/schemas.ts

@@ -1,7 +1,11 @@
 import type { Hash, Store } from "@ocas/core";
-import { putSchema } from "@ocas/core";
+import { bootstrap, putSchema } from "@ocas/core";
 import {
   ERROR_OUTPUT_SCHEMA,
+  OUTPUT_SCHEMAS,
+  OUTPUT_TEMPLATES,
+  type OutputSchemaName,
+  outputSchemaVarName,
   START_NODE_SCHEMA,
   STEP_NODE_SCHEMA,
   SUSPEND_OUTPUT_SCHEMA,
@@ -17,10 +21,12 @@ export type UwfSchemaHashes = {
   text: Hash;
   errorOutput: Hash;
   suspendOutput: Hash;
+  outputs: Record<OutputSchemaName, Hash>;
 };
 
 /**
- * Register Workflow, StartNode, and StepNode JSON Schemas in the CAS store.
+ * Register every uwf JSON Schema (workflow / start / step / error / suspend
+ * + the 9 CLI output envelopes) and the matching `text` Liquid templates.
  * Idempotent: safe to call on every CLI invocation.
  */
 export async function registerUwfSchemas(store: Store): Promise<UwfSchemaHashes> {
@@ -32,5 +38,35 @@ export async function registerUwfSchemas(store: Store): Promise<UwfSchemaHashes>
     putSchema(store, ERROR_OUTPUT_SCHEMA),
     putSchema(store, SUSPEND_OUTPUT_SCHEMA),
   ]);
-  return { workflow, startNode, stepNode, text, errorOutput, suspendOutput };
+  const outputs = await registerOutputSchemas(store);
+  return { workflow, startNode, stepNode, text, errorOutput, suspendOutput, outputs };
+}
+
+/**
+ * Register the 9 CLI output schemas, bind `@uwf/output/<name>` to each, store
+ * each Liquid template as an `@ocas/string` CAS node, and bind
+ * `@ocas/template/text/<schemaHash>` to the template content hash.
+ *
+ * Idempotent: writes are content-addressed so repeat invocations no-op.
+ */
+async function registerOutputSchemas(store: Store): Promise<Record<OutputSchemaName, Hash>> {
+  const aliases = bootstrap(store);
+  const stringHash = aliases["@ocas/string"];
+  if (stringHash === undefined) {
+    throw new Error("@ocas/string schema not found in bootstrap result");
+  }
+
+  const result = {} as Record<OutputSchemaName, Hash>;
+  const names = Object.keys(OUTPUT_SCHEMAS) as OutputSchemaName[];
+  for (const name of names) {
+    const schemaHash = await putSchema(store, OUTPUT_SCHEMAS[name]);
+    store.var.set(outputSchemaVarName(name), schemaHash);
+
+    const template = OUTPUT_TEMPLATES[name];
+    const contentHash = store.cas.put(stringHash, template);
+    store.var.set(`@ocas/template/text/${schemaHash}`, contentHash);
+
+    result[name] = schemaHash;
+  }
+  return result;
 }

package/src/store.ts

@@ -56,7 +56,7 @@ async function findIndexWorkflow(
  * Scan a single directory for workflow entries (flat YAML files + folder/index.yaml).
  * Returns discovered entries. Returns empty array if directory does not exist.
  */
-async function scanWorkflowDir(dir: string): Promise<ProjectWorkflowEntry[]> {
+export async function scanWorkflowDir(dir: string): Promise<ProjectWorkflowEntry[]> {
   let dirents: Dirent[];
   try {
     dirents = await readdir(dir, { withFileTypes: true });
@@ -159,6 +159,30 @@ export function getDefaultStorageRoot(): string {
   return join(homedir(), ".uwf");
 }
 
+/**
+ * Discover workflows from workflowPaths directories.
+ * Each directory is scanned directly for YAML files (like scanWorkflowDir).
+ * Earlier dirs in the list take priority on name collisions.
+ */
+export async function discoverWorkflowPathsEntries(
+  dirs: ReadonlyArray<string>,
+): Promise<ProjectWorkflowEntry[]> {
+  const seen = new Set<string>();
+  const result: ProjectWorkflowEntry[] = [];
+
+  for (const dir of dirs) {
+    const entries = await scanWorkflowDir(dir);
+    for (const entry of entries) {
+      if (!seen.has(entry.name)) {
+        seen.add(entry.name);
+        result.push(entry);
+      }
+    }
+  }
+
+  return result;
+}
+
 /**
  * Resolve storage root.
  * Priority: `UWF_HOME` → default.

package/src/text-renderers.ts

@@ -0,0 +1,355 @@
+/**
+ * Per-command text renderers — the per-command registry from spec
+ * `cli-format-text-renderer-registry.md`.
+ *
+ * Each renderer accepts the command's payload (already mapped via the
+ * output-mappers module) and returns a human-readable string. Renderers must
+ * never throw on partial/missing data and must never return `undefined`.
+ *
+ * Distinct from the existing Liquid template registry in `format.ts`: this
+ * registry is plain JS functions (the spec contract is
+ * `Record<string, (data: unknown) => string>`). The Liquid templates remain
+ * the primary rendering path inside `writeEnvelope`; these renderers are the
+ * fallback contract surface so callers can resolve `text` rendering without
+ * needing access to a CAS store.
+ */
+
+type ThreadListItem = {
+  threadId: string;
+  workflowHash: string;
+  workflowName: string | null;
+  status: string;
+  currentRole: string | null;
+  startedAt: number | null;
+  completedAt: number | null;
+};
+
+type ThreadListPayload = { items: ThreadListItem[] };
+
+type ThreadStatusPayload = {
+  threadId: string;
+  workflowHash: string;
+  head: string | null;
+  status: string;
+  currentRole: string | null;
+  suspendedRole: string | null;
+  suspendMessage: string | null;
+  done: boolean;
+};
+
+type ThreadStartPayload = {
+  threadId: string;
+  workflowHash: string;
+};
+
+type WorkflowListItem = {
+  name: string;
+  hash: string;
+  source: string;
+  description: string;
+};
+
+type WorkflowListPayload = { items: WorkflowListItem[] };
+
+type WorkflowDetailPayload = {
+  name: string;
+  hash: string;
+  version: number;
+  description: string;
+  roles: Record<string, { description: string; goal: string }>;
+  graph: Record<string, Record<string, { role: string; prompt: string }>>;
+};
+
+type StepListItem = {
+  hash: string;
+  role: string;
+  durationMs: number | null;
+};
+
+type StepListPayload = {
+  threadId: string;
+  items: StepListItem[];
+};
+
+type ThreadCancelPayload = {
+  thread: string;
+  cancelled: boolean;
+};
+
+type ThreadStopPayload = {
+  thread: string;
+  stopped: boolean;
+};
+
+type StepDetailPayload = {
+  hash: string;
+  role: string;
+  agent: string;
+  status: string;
+  startedAtMs: number | null;
+  completedAtMs: number | null;
+  durationMs: number | null;
+  frontmatter: Record<string, unknown>;
+  turns: Array<{ role: string; content: string; timestamp: number | null }>;
+};
+
+function asObject(data: unknown): Record<string, unknown> {
+  if (data !== null && typeof data === "object" && !Array.isArray(data)) {
+    return data as Record<string, unknown>;
+  }
+  return {};
+}
+
+function asString(value: unknown, fallback = "-"): string {
+  if (typeof value === "string" && value.length > 0) return value;
+  return fallback;
+}
+
+function asArray(value: unknown): unknown[] {
+  return Array.isArray(value) ? value : [];
+}
+
+function formatDuration(durationMs: unknown): string {
+  if (typeof durationMs !== "number" || !Number.isFinite(durationMs)) return "-";
+  if (durationMs >= 1000) return `${(durationMs / 1000).toFixed(1)}s`;
+  return `${durationMs}ms`;
+}
+
+function pad(s: string, width: number): string {
+  if (s.length >= width) return s.slice(0, width);
+  return s + " ".repeat(width - s.length);
+}
+
+function formatTimestamp(ts: unknown): string {
+  if (typeof ts !== "number" || !Number.isFinite(ts)) return "-";
+  const d = new Date(ts);
+  if (Number.isNaN(d.getTime())) return "-";
+  const pad2 = (n: number): string => n.toString().padStart(2, "0");
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+}
+
+export function renderThreadList(data: unknown): string {
+  const payload = asObject(data) as Partial<ThreadListPayload>;
+  const items = asArray(payload.items) as ThreadListItem[];
+  const lines: string[] = [
+    "THREAD                      WORKFLOW       STATUS     ROLE       STARTED",
+  ];
+  for (const item of items) {
+    const it = asObject(item);
+    const threadId = asString(it.threadId);
+    const workflowHash = asString(it.workflowHash);
+    const status = pad(asString(it.status), 9);
+    const role = pad(asString(it.currentRole), 10);
+    const started = formatTimestamp(it.startedAt);
+    lines.push(`${threadId}  ${workflowHash}  ${status} ${role} ${started}`);
+  }
+  return lines.join("\n");
+}
+
+export function renderThreadShow(data: unknown): string {
+  const p = asObject(data) as Partial<ThreadStatusPayload>;
+  const status = asString(p.status);
+  const role =
+    status === "suspended" && typeof p.suspendedRole === "string" && p.suspendedRole.length > 0
+      ? p.suspendedRole
+      : asString(p.currentRole);
+  const head = asString(p.head);
+  const lines = [
+    `Thread  ${asString(p.threadId)}`,
+    `Workflow ${asString(p.workflowHash)}`,
+    `Status  ${status}`,
+    `Role    ${role}`,
+    `Head    ${head}`,
+  ];
+  if (
+    status === "suspended" &&
+    typeof p.suspendMessage === "string" &&
+    p.suspendMessage.length > 0
+  ) {
+    lines.push(`Suspend  ${p.suspendMessage}`);
+  }
+  return lines.join("\n");
+}
+
+export function renderThreadStart(data: unknown): string {
+  const p = asObject(data) as Partial<ThreadStartPayload>;
+  return `Thread  ${asString(p.threadId)}\nWorkflow ${asString(p.workflowHash)}`;
+}
+
+export function renderWorkflowList(data: unknown): string {
+  const payload = asObject(data) as Partial<WorkflowListPayload>;
+  const items = asArray(payload.items) as WorkflowListItem[];
+  const lines: string[] = ["NAME          HASH           SOURCE     DESCRIPTION"];
+  for (const item of items) {
+    const it = asObject(item);
+    const name = pad(asString(it.name), 13);
+    const hash = asString(it.hash);
+    const source = pad(asString(it.source), 10);
+    const description = asString(it.description, "");
+    lines.push(`${name} ${hash}  ${source} ${description}`);
+  }
+  return lines.join("\n");
+}
+
+export function renderWorkflowShow(data: unknown): string {
+  const p = asObject(data) as Partial<WorkflowDetailPayload>;
+  const roles =
+    p.roles !== null && typeof p.roles === "object" && !Array.isArray(p.roles)
+      ? Object.keys(p.roles)
+      : [];
+  const lines = [
+    `Workflow  ${asString(p.name)}`,
+    `Version   ${typeof p.version === "number" ? p.version : "-"}`,
+    `Hash      ${asString(p.hash)}`,
+    `Roles     ${roles.join(", ")}`,
+  ];
+  if (typeof p.description === "string" && p.description.length > 0) {
+    lines.push(`Description ${p.description}`);
+  }
+  return lines.join("\n");
+}
+
+export function renderStepList(data: unknown): string {
+  const payload = asObject(data) as Partial<StepListPayload>;
+  const items = asArray(payload.items) as StepListItem[];
+  const lines: string[] = ["HASH           ROLE        DURATION"];
+  for (const item of items) {
+    const it = asObject(item);
+    const hash = asString(it.hash);
+    const role = pad(asString(it.role), 10);
+    const dur = formatDuration(it.durationMs);
+    lines.push(`${hash}  ${role}  ${dur}`);
+  }
+  return lines.join("\n");
+}
+
+export function renderStepShow(data: unknown): string {
+  const p = asObject(data) as Partial<StepDetailPayload>;
+  return [
+    `Step    ${asString(p.hash)}`,
+    `Role    ${asString(p.role)}`,
+    `Agent   ${asString(p.agent)}`,
+    `Status  ${asString(p.status)}`,
+    `Duration ${formatDuration(p.durationMs)}`,
+  ].join("\n");
+}
+
+export function renderThreadCancel(data: unknown): string {
+  const p = asObject(data) as Partial<ThreadCancelPayload>;
+  const cancelled = typeof p.cancelled === "boolean" ? (p.cancelled ? "yes" : "no") : "-";
+  return [
+    `Thread     ${asString(p.thread)}`,
+    `Status     cancelled`,
+    `Cancelled  ${cancelled}`,
+  ].join("\n");
+}
+
+export function renderThreadStop(data: unknown): string {
+  const p = asObject(data) as Partial<ThreadStopPayload>;
+  const stopped = typeof p.stopped === "boolean" ? (p.stopped ? "yes" : "no") : "-";
+  return [`Thread   ${asString(p.thread)}`, `Stopped  ${stopped}`].join("\n");
+}
+
+// ── Config renderers ────────────────────────────────────────────────
+
+/**
+ * Flatten a nested object into dot-notation key-value lines.
+ * Arrays are rendered as compact JSON; scalars as strings.
+ */
+function flattenConfig(obj: Record<string, unknown>, prefix: string): string[] {
+  const lines: string[] = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (Array.isArray(value)) {
+      lines.push(`${fullKey}\t${JSON.stringify(value)}`);
+    } else if (value !== null && typeof value === "object") {
+      lines.push(...flattenConfig(value as Record<string, unknown>, fullKey));
+    } else {
+      lines.push(`${fullKey}\t${String(value)}`);
+    }
+  }
+  return lines;
+}
+
+export function renderConfigList(data: unknown): string {
+  const obj = asObject(data);
+  if (Object.keys(obj).length === 0) return "";
+  return flattenConfig(obj as Record<string, unknown>, "").join("\n");
+}
+
+export function renderConfigGet(data: unknown): string {
+  const obj = asObject(data) as Record<string, unknown>;
+  const value = obj.value;
+  if (value === null || value === undefined) return "";
+  if (typeof value === "object" && !Array.isArray(value)) {
+    return flattenConfig(value as Record<string, unknown>, "").join("\n");
+  }
+  if (Array.isArray(value)) return JSON.stringify(value);
+  return String(value);
+}
+
+export function renderConfigSet(data: unknown): string {
+  const obj = asObject(data) as Record<string, unknown>;
+  const key = asString(obj.key as string | undefined);
+  const value = obj.value;
+  const rendered = Array.isArray(value) ? JSON.stringify(value) : String(value ?? "");
+  return `${key} = ${rendered}`;
+}
+
+// ── Log renderers ───────────────────────────────────────────────────
+
+type LogListItem = {
+  name: string;
+  size: number;
+  date: string;
+};
+
+type LogEntry = {
+  ts: string;
+  pid: string;
+  tag: string;
+  msg: string;
+  thread: string | null;
+  workflow: string | null;
+};
+
+function formatSize(bytes: unknown): string {
+  if (typeof bytes !== "number" || !Number.isFinite(bytes) || bytes < 0) return "-";
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}K`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}G`;
+}
+
+export function renderLogList(data: unknown): string {
+  const items = asArray(data) as LogListItem[];
+  if (items.length === 0) return "No log files.";
+  const lines: string[] = ["DATE        SIZE      NAME"];
+  for (const item of items) {
+    const it = asObject(item);
+    const date = pad(asString(it.date), 11);
+    const size = pad(formatSize(it.size), 9);
+    const name = asString(it.name);
+    lines.push(`${date} ${size} ${name}`);
+  }
+  return lines.join("\n");
+}
+
+export function renderLogShow(data: unknown): string {
+  const items = asArray(data) as LogEntry[];
+  if (items.length === 0) return "No log entries.";
+  const lines: string[] = [];
+  for (const item of items) {
+    const it = asObject(item);
+    const ts = asString(it.ts);
+    const pid = asString(it.pid);
+    const tag = asString(it.tag);
+    const msg = asString(it.msg, "");
+    const thread = typeof it.thread === "string" && it.thread.length > 0 ? it.thread : null;
+    const parts = [ts, `pid=${pid}`, tag];
+    if (thread !== null) parts.push(`thread=${thread}`);
+    parts.push(msg);
+    lines.push(parts.join(" "));
+  }
+  return lines.join("\n");
+}