@skillcdn/console 0.1.24 → 0.3.1

package/src/cli/credentials.ts

@@ -22,6 +22,11 @@ export interface Login {
   readonly agent: string | undefined;
   /** When the command was signed in, when known. */
   readonly since: string | undefined;
+  /**
+   * The workspace's time zone as the console last said it, at login or whoami (ADR-0035): what
+   * the command prints moments in, without asking again; none when the workspace names none.
+   */
+  readonly timeZone?: string | undefined;
 }
 
 /** Everything the command keeps: the logins, and the console a directory that names none works at. */
@@ -71,6 +76,7 @@ const loginSchema = z.object({
   token: z.string().check(z.minLength(1), z.maxLength(1024)),
   agent: z.optional(z.string().check(z.maxLength(200))),
   since: z.optional(z.string().check(z.maxLength(40))),
+  timeZone: z.optional(z.string().check(z.minLength(1), z.maxLength(64))),
 });
 const fileSchema = z.object({
   version: z.literal(2),
@@ -95,6 +101,7 @@ export function parseCredentials(json: unknown): Credentials | undefined {
         token: login.token,
         agent: login.agent,
         since: login.since,
+        ...(login.timeZone === undefined ? {} : { timeZone: login.timeZone }),
       })),
     };
   }

package/src/cli/directory.ts

@@ -15,6 +15,15 @@ import * as z from "zod/mini";
 /** The file's name, in the working directory or one above it. */
 export const DIRECTORY_FILE = ".skillcdn-console.json";
 
+/**
+ * The sentence a checkout's agreement carries to send the agents working there to the console:
+ * the one the skill working-the-board keeps (references/the-sentence.md) and this repository's
+ * own agreement carries. `console use` prints it, since nothing tells an agent to look until the
+ * checkout says so, as `skillcdn use` prints the sentence for a pack.
+ */
+export const THE_SENTENCE =
+  "**Bound to a console?** When `.skillcdn-console.json` is in this checkout, or `console whoami` names a project, work the task through that SkillCDN console (`console help` says how).";
+
 /** How large the file may be before it is not read: a few names, never more. */
 const MAX_FILE_CHARS = 16 * 1024;
 

package/src/cli/format.ts

@@ -15,17 +15,11 @@ import type {
   RestProjectRules,
   RestRules,
   RestRun,
-  RestSkillBrowse,
-  RestSkillBrowseEntry,
-  RestSkillFile,
-  RestSkillFind,
-  RestSkillLoad,
-  RestSkillPage,
-  RestSkills,
   RestTask,
   RestVersion,
   RestVersionSummary,
   RestWork,
+  RestWorkspace,
 } from "../schemas.js";
 
 // What the command prints: one line per thing in a list, a few lines for one thing in full.
@@ -34,6 +28,48 @@ import type {
 
 const plural = (count: number, word: string): string => `${count} ${word}${count === 1 ? "" : "s"}`;
 
+/** The time zone moments are printed in: the workspace's, as the command last learned it (ADR-0035); none leaves them as the API gives them. */
+let momentZone: string | undefined;
+
+/** Says which time zone the moments printed from now on are in, or none. */
+export function setMomentZone(zone: string | undefined): void {
+  momentZone = zone;
+}
+
+/**
+ * An instant as the command prints it: in the workspace's time zone, as ISO 8601 with its
+ * offset (`2026-10-18T15:04:17+09:00`), when a zone is known; else as the API gave it, in UTC.
+ */
+export function moment(iso: string): string {
+  if (momentZone === undefined) {
+    return iso;
+  }
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) {
+    return iso;
+  }
+  let parts: Intl.DateTimeFormatPart[];
+  try {
+    parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: momentZone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      timeZoneName: "longOffset",
+    }).formatToParts(date);
+  } catch {
+    return iso;
+  }
+  const of = (type: Intl.DateTimeFormatPartTypes): string =>
+    parts.find((part) => part.type === type)?.value ?? "";
+  const offset = of("timeZoneName").replace("GMT", "");
+  return `${of("year")}-${of("month")}-${of("day")}T${of("hour")}:${of("minute")}:${of("second")}${offset === "" ? "Z" : offset}`;
+}
+
 const indent = (text: string): string =>
   text
     .trimEnd()
@@ -61,7 +97,7 @@ export function formatProject(project: RestProject): string {
     `project ${project.key}: ${project.name}`,
     `visibility: ${project.visibility}  role: ${project.role}  skills: ${project.skillsAddress ?? "the organization's"}`,
     `color: ${project.color ?? "none"}  symbol: ${project.symbol ?? "none"}  image: ${project.icon === null ? "none" : project.icon.contentType}`,
-    `pack token: ${project.packToken === null ? "none" : `set ${project.packToken.setAt}`}`,
+    `pack token: ${project.packToken === null ? "none" : `set ${moment(project.packToken.setAt)}`}`,
   ];
   if (project.description.trim().length > 0) {
     lines.push("", project.description.trimEnd());
@@ -85,9 +121,25 @@ export function formatListingLine(listing: RestListing): string {
   return `${listing.login}  (let in at ${HOST_NAMES[listing.host]}, not signed in yet)`;
 }
 
+/** The workspace as its Settings page shows it: what it is called, who sees whom, the week, the time zone, where the skills come from, and what tokens may last. */
+export function formatWorkspace(workspace: RestWorkspace): string {
+  const visibility = workspace.peopleVisibility ?? "everyone";
+  const zone = workspace.timeZone ?? null;
+  const token = workspace.skills.packToken ?? null;
+  return [
+    `workspace ${workspace.name}`,
+    `people visibility: ${visibility}  (${visibility === "everyone" ? "everyone sees everyone" : "a member sees only the people they share a project with; an administrator sees everyone"})`,
+    `week begins on: ${workspace.weekStart ?? "auto"}  (auto: the system default, as each device has it)`,
+    `time zone: ${zone ?? "none"}  (${zone === null ? "moments are printed as the API gives them, in UTC" : "moments are printed in it, as ISO 8601 with its offset"})`,
+    `skills: ${workspace.skills.address ?? "no address of the organization's"}  at ${workspace.skills.source}`,
+    `SkillCDN token: ${token === null ? "none" : `set ${moment(token.setAt)}`}  (${token === null ? "the organization's pack is read with none" : "the organization's pack is read with it by a project with no address and no token of its own"})`,
+    `token days at most: ${workspace.tokenDaysAtMost ?? "a person chooses"}`,
+  ].join("\n");
+}
+
 /** One member of a project: their login, what they are in it, and since when. */
 export function formatMemberLine(member: RestMember): string {
-  return `${member.person.login}  ${member.role}  (since ${member.addedAt.slice(0, 10)})`;
+  return `${member.person.login}  ${member.role}  (since ${moment(member.addedAt).slice(0, 10)})`;
 }
 
 /** The line under a page of a listing that has more after it: how to ask for the next page. */
@@ -128,9 +180,9 @@ function scheduleLines(task: RestTask): string[] {
     lines.push(plan.join("  "));
   }
   const happened = [
-    task.startedAt === null ? undefined : `started: ${task.startedAt}`,
-    task.doneAt === null ? undefined : `done: ${task.doneAt}`,
-    task.archivedAt === null ? undefined : `archived: ${task.archivedAt}`,
+    task.startedAt === null ? undefined : `started: ${moment(task.startedAt)}`,
+    task.doneAt === null ? undefined : `done: ${moment(task.doneAt)}`,
+    task.archivedAt === null ? undefined : `archived: ${moment(task.archivedAt)}`,
   ].filter((part) => part !== undefined);
   if (happened.length > 0) {
     lines.push(happened.join("  "));
@@ -188,7 +240,7 @@ export function formatTask(
 export function formatComment(comment: RestComment): string {
   const who =
     comment.agent === null ? comment.author.login : `${comment.author.login} as ${comment.agent}`;
-  const lines = [`  ${who}, ${comment.createdAt}, comment ${comment.id}:`];
+  const lines = [`  ${who}, ${moment(comment.createdAt)}, comment ${comment.id}:`];
   if (comment.body.trim().length > 0) {
     lines.push(indent(comment.body));
   }
@@ -206,7 +258,7 @@ export function formatRunLine(run: RestRun): string {
     notes.push(`waiting for decision ${run.waitingFor}`);
   }
   if (run.endedAt === null) {
-    notes.push(`last heard ${run.lastHeardAt}`);
+    notes.push(`last heard ${moment(run.lastHeardAt)}`);
   }
   return `${run.id}  ${run.status}  ${run.agent} for ${run.person.login}  task #${run.taskNumber}  (${notes.join(", ")})`;
 }
@@ -215,7 +267,7 @@ export function formatRunLine(run: RestRun): string {
 export function formatRun(run: RestRun, fileUrl?: (artifactId: string) => string): string {
   const lines = [
     formatRunLine(run),
-    `started: ${run.startedAt}${run.endedAt === null ? "" : `  ended: ${run.endedAt}`}`,
+    `started: ${moment(run.startedAt)}${run.endedAt === null ? "" : `  ended: ${moment(run.endedAt)}`}`,
   ];
   if (run.summary !== null) {
     lines.push("", "summary:", indent(run.summary));
@@ -223,7 +275,7 @@ export function formatRun(run: RestRun, fileUrl?: (artifactId: string) => string
   if (run.reports.length > 0) {
     lines.push("", "reports:");
     for (const report of run.reports) {
-      lines.push(`  [${report.createdAt}]`, indent(report.body));
+      lines.push(`  [${moment(report.createdAt)}]`, indent(report.body));
     }
   }
   if (run.artifacts.length > 0) {
@@ -247,77 +299,13 @@ export function formatArtifact(
   return artifact.label === null ? what : `${artifact.label}: ${what}`;
 }
 
-const SKILLS_WORDS: Readonly<Record<Exclude<RestSkills["status"], "none" | "ready">, string>> = {
-  indexing: "SkillCDN is still indexing the repository; ask again in a moment.",
-  failed: "SkillCDN could not index the repository.",
-  not_found:
-    "SkillCDN does not serve this address to the console: nothing is there, or the pack is private and the project holds no pack token for it (console project pack-token <key> --stdin, for an owner).",
-  token_invalid:
-    "The pack token the project holds no longer works at SkillCDN: an owner sets a new one (console project pack-token <key> --stdin).",
-  unavailable: "SkillCDN could not be reached; ask again later.",
-};
-
-/** A count with its noun: `1 skill`, `2 skills`. */
-const counted = (n: number, noun: string): string => `${n} ${noun}${n === 1 ? "" : "s"}`;
-
-/**
- * The organization's skills: where they are, the pack by name and by count, each skill with
- * what an agent loads it by, where a person connects an agent that has no connection to the
- * address, and where the console's own skills are on this machine, when the command knows.
- */
-export function formatSkills(skills: RestSkills, ownSkills?: string): string {
-  const own =
-    ownSkills === undefined
-      ? []
-      : ["", `The console's own skills, for working the board: ${ownSkills}`];
-  if (skills.status === "none" || skills.address === null || skills.page === null) {
-    return ["No skills address: neither this project nor the console names one.", ...own].join(
-      "\n",
-    );
-  }
-  const head = `skills at ${skills.address}, served by ${skills.source}: ${skills.status}`;
-  if (skills.status !== "ready") {
-    return [head, SKILLS_WORDS[skills.status], ...own].join("\n");
-  }
-  const lines = [head];
-  if (skills.pack !== undefined) {
-    const named = [skills.pack.name, skills.pack.description]
-      .filter((text): text is string => text !== null)
-      .join("  ");
-    if (named !== "") {
-      lines.push(named);
-    }
-  }
-  if (skills.counts !== undefined) {
-    lines.push(
-      `${counted(skills.counts.skills, "skill")}, ${counted(skills.counts.documents, "document")}: console skills <folder> shows what a folder holds (. for the root), console skills --search <words> finds skills and documents by words.`,
-    );
-  }
-  if (skills.items.length === 0) {
-    lines.push("No skills at this address.");
-  }
-  // The path, which console skill takes, and the URI beside it, which a host's own connection takes.
-  for (const skill of skills.items) {
-    lines.push(
-      `${skill.name}  ${skill.description}`,
-      `    ${skill.path}${skill.uri === null ? "" : `  ${skill.uri}`}`,
-    );
-  }
-  lines.push(
-    "",
-    `Read a skill whole with console skill <path>, its rules first, and a file of the pack with console skill --file <path>; or load it by its URI through your own SkillCDN connection to this address, which a person makes at ${skills.page}. --json adds the page of each, for a person.`,
-    ...own,
-  );
-  return lines.join("\n");
-}
-
 /** One half of the rules: where it comes from, and the text as it stands. */
 function formatRulesHalf(where: "the workspace" | "this project", rules: RestRules): string {
   const page = rules.page;
   const facts =
     page === null
       ? undefined
-      : `v${page.version}, by ${writer(page.updatedBy, page.agent)}; ${page.updatedAt}`;
+      : `v${page.version}, by ${writer(page.updatedBy, page.agent)}; ${moment(page.updatedAt)}`;
   if (rules.source === "none" || rules.body === null) {
     return `Rules of ${where}: none of its own; the workspace's hold.`;
   }
@@ -417,19 +405,25 @@ export function formatDecisionLine(decision: RestDecision): string {
   return `${decision.id}  ${state}  ${decision.question}  (asked by ${asker(decision)})`;
 }
 
+/** The options, one a line; the person's own answer, when they wrote one, is the last and says so. */
 export function formatOptions(decision: RestDecision): string {
-  return decision.options.map((option) => `  ${option.id}) ${option.label}`).join("\n");
+  return decision.options
+    .map(
+      (option) =>
+        `  ${option.id}) ${option.label}${option.own === true ? "  (the person's own answer, not one given)" : ""}`,
+    )
+    .join("\n");
 }
 
-/** The answer, with who gave it; or that there is none yet. */
+/** The answer, with who gave it, and that it is in their own words when it is; or that there is none yet. */
 export function formatAnswer(decision: RestDecision): string {
   const { answer } = decision;
   if (answer === null) {
     return "waits for a person.";
   }
-  const label = decision.options.find((option) => option.id === answer.option)?.label;
+  const chosen = decision.options.find((option) => option.id === answer.option);
   const lines = [
-    `Answered: ${answer.option}) ${label ?? answer.option}, by ${answer.by.login} at ${answer.at}`,
+    `Answered: ${answer.option}) ${chosen?.label ?? answer.option}${chosen?.own === true ? ", in their own words" : ""}, by ${answer.by.login} at ${answer.at}`,
   ];
   if (answer.note !== null && answer.note.length > 0) {
     lines.push(`Note: ${answer.note}`);
@@ -462,7 +456,7 @@ export function formatDocumentLine(document: RestDocumentSummary): string {
   if (document.archivedAt !== null) {
     notes.push("archived");
   }
-  return `${document.path}  ${document.title}  (${notes.join(", ")}; ${document.updatedAt})`;
+  return `${document.path}  ${document.title}  (${notes.join(", ")}; ${moment(document.updatedAt)})`;
 }
 
 /** A folder's folders and pages, or the pages a search found. */
@@ -484,7 +478,7 @@ export function formatDocument(
 ): string {
   const lines = [
     `${document.path}: ${document.title}`,
-    `version ${document.version}, by ${writer(document.updatedBy, document.agent)} at ${document.updatedAt}${document.archivedAt === null ? "" : `; archived ${document.archivedAt}`}`,
+    `version ${document.version}, by ${writer(document.updatedBy, document.agent)} at ${moment(document.updatedAt)}${document.archivedAt === null ? "" : `; archived ${moment(document.archivedAt)}`}`,
     `id: ${document.id}`,
   ];
   if (document.body.trim().length > 0) {
@@ -518,7 +512,7 @@ export function formatDocument(
 }
 
 export function formatVersionLine(version: RestVersionSummary): string {
-  return `v${version.number}  ${version.title}  (by ${writer(version.author, version.agent)}; ${version.createdAt})`;
+  return `v${version.number}  ${version.title}  (by ${writer(version.author, version.agent)}; ${moment(version.createdAt)})`;
 }
 
 /** One version of a document, with its body as it was. */
@@ -531,256 +525,3 @@ export function formatVersion(path: string, version: RestVersion): string {
 }
 
 /** The text of one path across the pages a skill came in: the fragments joined in order. */
-function joinTexts(
-  pages: readonly RestSkillPage[],
-  pick: (page: RestSkillPage) => readonly { readonly path: string; readonly body: string }[],
-): { readonly path: string; readonly body: string }[] {
-  const joined = new Map<string, string>();
-  for (const page of pages) {
-    for (const text of pick(page)) {
-      joined.set(text.path, (joined.get(text.path) ?? "") + text.body);
-    }
-  }
-  return [...joined.entries()].map(([path, body]) => ({ path, body }));
-}
-
-const NO_ADDRESS = "No skills address: neither this project nor the console names one.";
-
-/**
- * One skill, as load_skill lays it out for a model (ADR-0028): the rules from the repository's
- * root to the nearest manifest, the body, the included files, each under a line that names its
- * path; then the files the skill has and what it refers to. A skill described only is named and
- * pointed at, and nothing of its body is shown.
- */
-export function formatSkillLoad(loaded: RestSkillLoad, pages: readonly RestSkillPage[]): string {
-  if (loaded.status === "none" || loaded.address === null) {
-    return NO_ADDRESS;
-  }
-  const head = `skill at ${loaded.address}, served by ${loaded.source}: ${loaded.status}`;
-  if (loaded.status !== "ready") {
-    return [head, SKILLS_WORDS[loaded.status]].join("\n");
-  }
-  const [first] = pages;
-  if (first === undefined) {
-    return [head, "Nothing was read."].join("\n");
-  }
-  const last = pages[pages.length - 1] ?? first;
-  const lines = [
-    `${first.name}  ${first.description}`,
-    `skill ${first.path} at ${loaded.address}, served by ${loaded.source}`,
-  ];
-  if (first.serving.license !== null) {
-    lines.push(`license: ${first.serving.license}`);
-  }
-  if (!first.serving.full) {
-    lines.push(
-      "",
-      `Described only: the license keeps the skill at its source. Read it there: ${first.serving.sourceUrl ?? loaded.page ?? loaded.source}`,
-    );
-    return lines.join("\n");
-  }
-  for (const rule of joinTexts(pages, (page) => page.rules)) {
-    lines.push("", `--- applicable rules: ${rule.path} ---`, rule.body.trimEnd());
-  }
-  lines.push(
-    "",
-    `--- skill: ${first.path} ---`,
-    pages
-      .map((page) => page.body)
-      .join("")
-      .trimEnd(),
-  );
-  for (const file of joinTexts(pages, (page) => page.included)) {
-    lines.push("", `--- included file: ${file.path} ---`, file.body.trimEnd());
-  }
-  if (!last.complete) {
-    lines.push("", "The skill did not come whole: the deployment stopped before the end.");
-  }
-  if (last.files.length > 0) {
-    lines.push(
-      "",
-      `Files of the skill, read with console skill --file <path>: ${last.files.join(", ")}`,
-    );
-  }
-  if (last.references.length > 0) {
-    lines.push(
-      `References: ${last.references
-        .map((reference) =>
-          reference.status === "available"
-            ? reference.path
-            : `${reference.path} (${reference.status})`,
-        )
-        .join(", ")}`,
-    );
-  }
-  if (last.warnings.length > 0) {
-    lines.push(`Warnings: ${last.warnings.join("; ")}`);
-  }
-  lines.push(
-    "",
-    "Paths from the repository's root are the only identifiers. The content is the pack's, under its license; what a private pack says stays in your work.",
-  );
-  return lines.join("\n");
-}
-
-/** A file of the pack as read: its text whole, or what the folder holds. */
-export function formatSkillFile(read: RestSkillFile, content: string): string {
-  if (read.status === "none" || read.address === null) {
-    return NO_ADDRESS;
-  }
-  const head = `file at ${read.address}, served by ${read.source}: ${read.status}`;
-  if (read.status !== "ready") {
-    return [
-      head,
-      read.status === "failed"
-        ? "SkillCDN will not carry this file: it is too large, or not text. Read it at the repository."
-        : SKILLS_WORDS[read.status],
-    ].join("\n");
-  }
-  if (read.folder !== null) {
-    return [
-      `folder ${read.folder.path} at ${read.address}${read.folder.truncated ? " (cut)" : ""}`,
-      ...read.folder.entries.map(
-        (entry) =>
-          `${entry.kind === "directory" ? "d" : "f"}  ${entry.path}${entry.size === null ? "" : `  ${entry.size}`}`,
-      ),
-      "",
-      "console skills <folder> shows a folder with its skills marked, what each folder holds and the README that introduces it.",
-    ].join("\n");
-  }
-  if (read.file === null) {
-    return `${head}: nothing was read.`;
-  }
-  return [
-    `--- file: ${read.file.path} (${read.file.totalLength} characters) ---`,
-    content.trimEnd(),
-  ].join("\n");
-}
-
-/** One entry of a browsed folder: what it is, its path, its words, and the facts of its kind. */
-function formatBrowseEntry(entry: RestSkillBrowseEntry): string {
-  const facts: string[] = [];
-  if (entry.kind === "directory") {
-    if (entry.skillCount > 0) {
-      facts.push(counted(entry.skillCount, "skill"));
-    }
-    if (entry.documentCount > 0) {
-      facts.push(counted(entry.documentCount, "document"));
-    }
-    if (entry.overviewPath !== null) {
-      facts.push(`README ${entry.overviewPath}`);
-    }
-  }
-  if (entry.kind === "skill") {
-    if (entry.license !== null) {
-      facts.push(entry.license);
-    }
-    if (entry.describedOnly) {
-      facts.push("described only");
-    }
-  }
-  if (entry.kind === "file" && entry.size !== null) {
-    facts.push(`${entry.size} bytes`);
-  }
-  const words = [entry.name, entry.description]
-    .filter((text): text is string => text !== null && text !== "")
-    .join("  ");
-  const mark = entry.kind === "skill" ? "skill" : entry.kind === "directory" ? "d" : "f";
-  return `${mark}  ${entry.path}${words === "" ? "" : `  ${words}`}${facts.length === 0 ? "" : `  (${facts.join("; ")})`}`;
-}
-
-/**
- * What a folder of the pack holds, as browse_repo lays it out: the README that introduces the
- * folder, then its skills, its folders with what each holds, and its files, across the pages the
- * listing came in.
- */
-export function formatSkillBrowse(
-  browsed: RestSkillBrowse,
-  folders: readonly NonNullable<RestSkillBrowse["folder"]>[],
-): string {
-  if (browsed.status === "none" || browsed.address === null) {
-    return NO_ADDRESS;
-  }
-  const head = `folder at ${browsed.address}, served by ${browsed.source}: ${browsed.status}`;
-  if (browsed.status !== "ready") {
-    return [head, SKILLS_WORDS[browsed.status]].join("\n");
-  }
-  const [first] = folders;
-  if (first === undefined) {
-    return [head, "Nothing was read."].join("\n");
-  }
-  const last = folders[folders.length - 1] ?? first;
-  const lines = [`folder ${first.path === "" ? "/" : first.path} at ${browsed.address}`];
-  if (first.overview !== null) {
-    const words = [first.overview.title, first.overview.description]
-      .filter((text): text is string => text !== null && text !== "")
-      .join("  ");
-    lines.push(`    ${words === "" ? "" : `${words}  `}(README: ${first.overview.path})`);
-  }
-  const entries = folders.flatMap((folder) => folder.entries);
-  if (entries.length === 0) {
-    lines.push("Nothing in this folder.");
-  }
-  for (const entry of entries) {
-    lines.push(formatBrowseEntry(entry));
-  }
-  if (last.nextCursor !== null) {
-    lines.push("More entries: the listing stopped before the end of the folder.");
-  }
-  lines.push(
-    "",
-    "Read a skill with console skill <path>; a file, or a README named above, with console skill --file <path>; a folder with console skills <folder>.",
-  );
-  return lines.join("\n");
-}
-
-/**
- * What words found in the pack, as search_repo lays it out: skills with the files of theirs that
- * matched, documents on their own, in relevance order; words, not meaning.
- */
-export function formatSkillFind(found: RestSkillFind): string {
-  if (found.status === "none" || found.address === null) {
-    return NO_ADDRESS;
-  }
-  const head = `search at ${found.address}, served by ${found.source}: ${found.status}`;
-  if (found.status !== "ready") {
-    return [head, SKILLS_WORDS[found.status]].join("\n");
-  }
-  if (found.found === null) {
-    return [head, "Nothing was read."].join("\n");
-  }
-  const { query, path, items, nextCursor } = found.found;
-  const where = path === null || path === "" ? "" : ` within ${path}`;
-  const lines = [
-    `found for "${query}"${where} at ${found.address}: ${counted(items.length, "result")}`,
-  ];
-  for (const item of items) {
-    if (item.kind === "skill") {
-      lines.push(
-        `skill  ${item.path}  ${item.name}  ${item.description}${item.describedOnly ? "  (described only)" : ""}`,
-      );
-      for (const file of item.files) {
-        lines.push(`    file  ${file.path}${file.title === null ? "" : `  ${file.title}`}`);
-      }
-      if (item.moreFiles > 0) {
-        lines.push(`    and ${counted(item.moreFiles, "more file")}`);
-      }
-    } else {
-      lines.push(
-        `document  ${item.path}${item.title === null ? "" : `  ${item.title}`}${item.summary === null ? "" : `  ${item.summary}`}`,
-      );
-    }
-  }
-  if (nextCursor !== null) {
-    lines.push(
-      "More matched: narrow the words, or search within a folder (console skills <folder> --search <words>).",
-    );
-  }
-  if (items.length > 0) {
-    lines.push(
-      "",
-      "Read a skill with console skill <path>, a file or a document with console skill --file <path>.",
-    );
-  }
-  return lines.join("\n");
-}