@monster-orange/den 0.2.4 → 0.2.6

package/src/shared/stacks/compose-health.ts

@@ -0,0 +1,242 @@
+/**
+ * Compose-stack health answered in-process, from one `docker ps` listing
+ * shared by every check that runs at the same time.
+ *
+ * Den gives a compose repo with no declared check a `<cli> stack health`
+ * shell check (composeHealthCmd), one per manifest service. Spawned, each
+ * was a full CLI start: 17-19 tsx processes per health cycle for three
+ * stacks, which on a loaded machine (load 35-55) ran past their budget and
+ * read as down. The checks Den generates itself are now judged here, with
+ * the verdict `stack health` gives; a distribution's own shell checks still
+ * run as shell commands.
+ */
+import { execFile } from "child_process";
+import type { RawManifest } from "../types/index.js";
+import { manifestStackName } from "./config.js";
+import { composeHealthCmd } from "./manifest-commands.js";
+import { projectName } from "./render.js";
+import { judgeStackRows, type ComposeRow } from "./runtime.js";
+import { resolveStackWorkspaces } from "./status.js";
+
+export { judgeStackRows, type ComposeRow };
+
+/** A Den-generated compose health check: what to look for in the listing. */
+export interface ComposeHealthTarget {
+  /** The Compose project (`<stack>-<stack workspace>`). */
+  project: string;
+  /** A compose service to check on its own; unset: the whole stack. */
+  service?: string;
+  /** The equivalent `<cli> stack health` command (shown as the check). */
+  cmd: string;
+}
+
+/** A health verdict; `ok: null` when docker could not be asked. */
+export interface ComposeVerdict {
+  ok: boolean | null;
+  detail: string;
+  /** With ok null: docker gave no answer within the budget. */
+  pending?: boolean;
+}
+
+/** The compose health check Den generates for this service, or null. */
+export function composeHealthTarget(
+  manifest: RawManifest,
+  subsystem: string,
+  repoName: string,
+  workspace: string,
+): ComposeHealthTarget | null {
+  const cmd = composeHealthCmd(manifest, subsystem, repoName, workspace);
+  if (!cmd) return null;
+  const project = projectName(
+    manifestStackName(manifest, repoName),
+    resolveStackWorkspaces(workspace).stackWorkspace,
+  );
+  const service = cmd.includes(" --service ") ? subsystem : undefined;
+  return { project, ...(service ? { service } : {}), cmd };
+}
+
+/** Budget for the shared listing; past it the checks are pending. */
+export const COMPOSE_LISTING_TIMEOUT_MS = 5_000;
+
+/** The shared listing: every container, or why docker could not answer. */
+export type ComposeListing =
+  | { rows: ComposeRow[] }
+  | { error: string; pending?: boolean };
+type Listing = ComposeListing;
+
+let inFlight: Promise<Listing> | null = null;
+
+/**
+ * Every container, from one `docker ps -a`. Concurrent callers share the
+ * call in flight, so a health cycle lists once however many checks it has
+ * (compose checks and `type: container` checks alike). Not filtered to
+ * compose containers: a container check may name a plain container.
+ */
+export function composeListing(): Promise<Listing> {
+  return (inFlight ??= listOnce().finally(() => {
+    inFlight = null;
+  }));
+}
+
+function listOnce(): Promise<Listing> {
+  return new Promise((done) => {
+    // Backstop: execFile reports only once the pipes close, which a killed
+    // process's children can hold open; the checks must not wait on that.
+    const guard = setTimeout(
+      () =>
+        resolve({
+          error: `docker gave no answer within ${COMPOSE_LISTING_TIMEOUT_MS / 1000}s`,
+          pending: true,
+        }),
+      COMPOSE_LISTING_TIMEOUT_MS + 500,
+    );
+    let settled = false;
+    const resolve = (l: Listing): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(guard);
+      done(l);
+    };
+    execFile(
+      "docker",
+      [
+        "ps",
+        "-a",
+        "--format",
+        '{{.Label "com.docker.compose.project"}}\t{{.Label "com.docker.compose.service"}}\t{{.State}}\t{{.Status}}\t{{.Names}}',
+      ],
+      {
+        encoding: "utf-8",
+        timeout: COMPOSE_LISTING_TIMEOUT_MS,
+        maxBuffer: 16 * 1024 * 1024,
+      },
+      (err, stdout, stderr) => {
+        if (err) {
+          const killed = (err as { killed?: boolean }).killed === true;
+          return resolve(
+            killed
+              ? {
+                  error: `docker gave no answer within ${COMPOSE_LISTING_TIMEOUT_MS / 1000}s`,
+                  pending: true,
+                }
+              : {
+                  error:
+                    String(stderr || err.message).trim() || "docker ps failed",
+                },
+          );
+        }
+        const rows = stdout
+          .split("\n")
+          .filter(Boolean)
+          .map((line) => {
+            const [
+              project = "",
+              service = "",
+              state = "",
+              status = "",
+              name = "",
+            ] = line.split("\t");
+            return { project, service, state, status, name };
+          });
+        resolve({ rows });
+      },
+    );
+  });
+}
+
+/**
+ * The verdict when docker gave no listing, shared by compose and container
+ * checks so the two cannot drift: container state unknown is not "not
+ * running" (`ok: null`, never down, however often it repeats). Only a
+ * listing past its budget is `pending` (no answer in time), which, like any
+ * timeout, is down when it repeats on the next cycle.
+ */
+export function unknownListingVerdict(listing: {
+  error: string;
+  pending?: boolean;
+}): ComposeVerdict {
+  return {
+    ok: null,
+    detail: `container state unknown: ${listing.error}`,
+    ...(listing.pending ? { pending: true } : {}),
+  };
+}
+
+/** The health of one Den-generated compose check, from the shared listing. */
+export async function composeHealth(
+  target: ComposeHealthTarget,
+): Promise<ComposeVerdict> {
+  const listing = await composeListing();
+  if ("error" in listing) return unknownListingVerdict(listing);
+  return judgeStackRows(listing.rows, target.project, target.service);
+}
+
+// ── `health: { type: container }` ───────────────────────────────────────────
+
+/**
+ * A declared container check: a compose container by its project and service
+ * labels, or any container by name (`container_name`).
+ */
+export type ContainerHealthTarget =
+  | { project: string; service: string; container_name?: undefined }
+  | { container_name: string; project?: undefined; service?: undefined };
+
+/** What a container check shows as its check: `container <project>/<service>`. */
+export function containerCheckLabel(t: ContainerHealthTarget): string {
+  return `container ${containerTargetName(t)}`;
+}
+
+function containerTargetName(t: ContainerHealthTarget): string {
+  return t.container_name ?? `${t.project}/${t.service}`;
+}
+
+function matchesTarget(r: ComposeRow, t: ContainerHealthTarget): boolean {
+  if (t.container_name)
+    return (r.name ?? "")
+      .split(",")
+      .map((n) => n.trim().replace(/^\//, ""))
+      .includes(t.container_name);
+  return r.project === t.project && r.service === t.service;
+}
+
+/** One container's verdict: its healthcheck when it has one, else running. */
+function rowVerdict(r: ComposeRow): ComposeVerdict & { rank: number } {
+  const what = `${r.name || `${r.project}/${r.service}`}\t${r.state}\t${r.status}`;
+  if (r.state !== "running") return { ok: false, detail: what, rank: 4 };
+  if (/\(unhealthy\)/.test(r.status))
+    return { ok: false, detail: what, rank: 3 };
+  // Starting is pending, but not "no answer": it never turns down on repeat.
+  if (/\(health: starting\)/.test(r.status))
+    return { ok: null, detail: what, rank: 2 };
+  if (/\(healthy\)/.test(r.status)) return { ok: true, detail: what, rank: 0 };
+  return { ok: true, detail: what, rank: 1 };
+}
+
+/**
+ * The verdict of a container check over the shared listing. More than one
+ * match: the best one (healthy, then running). No match: down. No listing:
+ * as a compose check (unknownListingVerdict), the reason in `detail`.
+ */
+export function judgeContainerListing(
+  listing: ComposeListing,
+  target: ContainerHealthTarget,
+): ComposeVerdict {
+  if ("error" in listing) return unknownListingVerdict(listing);
+  const best = listing.rows
+    .filter((r) => matchesTarget(r, target))
+    .map(rowVerdict)
+    .sort((a, b) => a.rank - b.rank)[0];
+  if (!best)
+    return {
+      ok: false,
+      detail: `${containerTargetName(target)}: no container`,
+    };
+  return { ok: best.ok, detail: best.detail };
+}
+
+/** The health of a declared container check, from the shared listing. */
+export async function containerHealth(
+  target: ContainerHealthTarget,
+): Promise<ComposeVerdict> {
+  return judgeContainerListing(await composeListing(), target);
+}

package/src/shared/stacks/runtime.ts

@@ -364,39 +364,88 @@ export function stackLogs(
 
 /**
  * Health of a running stack: ok when it has containers, all are running, and
- * none reports a failing or pending Docker healthcheck.
+ * none reports a failing or pending Docker healthcheck. `ok: null` when
+ * docker could not be asked: container state unknown is not "not running".
  */
 export function stackHealth(
   ctx: StackContext,
   s: StackConfig,
   service?: string,
-): { ok: boolean; detail: string } {
+): { ok: boolean | null; detail: string } {
   const project = projectName(s.name, ctx.workspace);
-  const r = run("docker", [
-    "ps",
-    "-a",
-    "--filter",
-    `label=com.docker.compose.project=${project}`,
-    ...(service
-      ? ["--filter", `label=com.docker.compose.service=${service}`]
-      : []),
-    "--format",
-    '{{.Label "com.docker.compose.service"}}\t{{.State}}\t{{.Status}}',
-  ]);
-  if (r.code !== 0) return { ok: false, detail: r.err || "docker ps failed" };
-  const rows = r.out.split("\n").filter(Boolean);
-  if (!rows.length)
+  let r: ReturnType<typeof run>;
+  try {
+    r = run("docker", [
+      "ps",
+      "-a",
+      "--filter",
+      `label=com.docker.compose.project=${project}`,
+      ...(service
+        ? ["--filter", `label=com.docker.compose.service=${service}`]
+        : []),
+      "--format",
+      '{{.Label "com.docker.compose.service"}}\t{{.State}}\t{{.Status}}',
+    ]);
+  } catch (e) {
+    return {
+      ok: null,
+      detail: `container state unknown: ${(e as Error).message}`,
+    };
+  }
+  if (r.code !== 0)
+    return {
+      ok: null,
+      detail: `container state unknown: ${r.err.trim() || "docker ps failed"}`,
+    };
+  const rows = r.out
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      const [svc = "", state = "", status = ""] = line.split("\t");
+      return { project, service: svc, state, status };
+    });
+  return judgeStackRows(rows, project, service);
+}
+
+/** One compose container, as a `docker ps` listing reports it. */
+export interface ComposeRow {
+  project: string;
+  service: string;
+  state: string;
+  status: string;
+  /** The container's name(s), comma-separated as docker lists them. */
+  name?: string;
+}
+
+/**
+ * The verdict `stack health` gives for `project` (and `service`): ok when it
+ * has containers, all running, none with a failing or starting Docker
+ * healthcheck. Shared by the CLI and the in-process check (compose-health).
+ */
+export function judgeStackRows(
+  rows: ComposeRow[],
+  project: string,
+  service?: string,
+): { ok: boolean; detail: string } {
+  const mine = rows.filter(
+    (r) => r.project === project && (!service || r.service === service),
+  );
+  if (!mine.length)
     return {
       ok: false,
       detail: `${project}${service ? `/${service}` : ""}: not running`,
     };
-  const bad = rows.filter((row) => {
-    const [, state, status] = row.split("\t");
-    return (
-      state !== "running" || /\((unhealthy|health: starting)\)/.test(status)
-    );
-  });
+  const bad = mine.filter(
+    (r) =>
+      r.state !== "running" ||
+      /\((unhealthy|health: starting)\)/.test(r.status),
+  );
   return bad.length
-    ? { ok: false, detail: bad.join("; ") }
-    : { ok: true, detail: `${rows.length} container(s) running` };
+    ? {
+        ok: false,
+        detail: bad
+          .map((r) => `${r.service}\t${r.state}\t${r.status}`)
+          .join("; "),
+      }
+    : { ok: true, detail: `${mine.length} container(s) running` };
 }

package/src/shared/stacks/status.ts

@@ -34,7 +34,8 @@ export interface StackStatus {
   routes: StackRoute[];
   uses: string[];
   /** Container health (only when asked for: it runs `docker ps`). */
-  health?: { ok: boolean; detail: string };
+  /** `ok: null`: docker could not be asked, so the state is unknown. */
+  health?: { ok: boolean | null; detail: string };
 }
 
 const WS_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
@@ -96,7 +97,7 @@ export function stackStatuses(
       try {
         status.health = healthOf(ctx, s);
       } catch (e) {
-        status.health = { ok: false, detail: (e as Error).message };
+        status.health = { ok: null, detail: (e as Error).message };
       }
     }
     return status;

package/src/shared/types/index.ts

@@ -210,10 +210,22 @@ export type LogSource =
  *   type: shell
  *   cmd: "docker exec $(docker ps --filter ancestor=postgres:16 --format '{{.ID}}' | head -1) pg_isready -U postgres"
  *   label: "postgres"   # optional — shown in UI instead of cmd
+ *
+ * Container (answered from the one `docker ps` a health cycle shares):
+ *   type: container
+ *   project: shop-main     # com.docker.compose.project label
+ *   service: db            # com.docker.compose.service label
+ *   -- or, for a container not run by compose --
+ *   type: container
+ *   container_name: shop-db
  */
 export type ServiceHealthConfig =
   | { type?: "http"; url: string; label?: string }
-  | { type: "shell"; cmd: string; label?: string };
+  | { type: "shell"; cmd: string; label?: string }
+  | ({ type: "container"; label?: string } & (
+      | { project: string; service: string; container_name?: undefined }
+      | { container_name: string; project?: undefined; service?: undefined }
+    ));
 
 /**
  * A command can be a plain shell string (detached by default) or an object

package/src/ui/cli/create.ts

@@ -15,6 +15,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { ENGINE_PACKAGE, getEngineRoot } from "../../shared/paths.js";
 import { profileFrom } from "../../shared/profile.js";
+import { plural } from "../../shared/plural.js";
 
 export interface CreateOptions {
   /** Product name: lower-case `[a-z][a-z0-9-]*`. */
@@ -345,7 +346,7 @@ export function runCreate(argv: string[], cwd: string): number {
     const cli = args.cli ?? args.name;
     const rel = path.relative(cwd, args.dir) || ".";
     console.log(
-      `Created ${args.name} in ${args.dir} (${written.length} files).`,
+      `Created ${args.name} in ${args.dir} (${plural(written.length, "file")}).`,
     );
     console.log("");
     console.log("Next:");

package/src/ui/cli/health-display.ts

@@ -13,6 +13,7 @@ export function healthLabelText(health: HealthState): string {
 export function formatHealthLabel(health: HealthState): string {
   if (health === "ok") return chalk.green("● ok");
   if (health === "error") return chalk.red("● down");
+  if (health === "pending") return chalk.gray("● pending");
   return chalk.gray("● unknown");
 }
 

package/src/ui/cli/index.ts

@@ -12,18 +12,10 @@ import {
 } from "../../shared/stacks/status.js";
 import { isNamedTarget } from "./named-target.js";
 import chalk from "chalk";
-import oraSpinner from "ora";
-
-/**
- * Spinners are progress, not diagnostics: on a terminal they animate on
- * stderr as usual; piped (CI, scripts) their lines go to stdout so stderr
- * carries only real warnings and errors.
- */
-const ora = (text: string) =>
-  oraSpinner({
-    text,
-    stream: process.stderr.isTTY ? process.stderr : process.stdout,
-  });
+import { noun, plural } from "../../shared/plural.js";
+// Spinners: progress on stderr (a terminal) or stdout (piped); plain lines
+// where they cannot animate. See spinner.ts.
+import { spinner as ora } from "./spinner.js";
 import Table from "cli-table3";
 import { cliPrompts } from "./prompts.js";
 import { resultsViewer } from "./results-viewer.js";
@@ -85,9 +77,12 @@ import {
   resolveServiceRuntime,
 } from "../../shared/environment-manager/service-runner.js";
 import {
-  defaultWorkspaceRepos,
+  blueprintWorkspaces,
   defaultWorkspaceNeedsSeeding,
+  blueprintAlreadySeeded,
   defaultWorkspaceHasServices,
+  isMultiBlueprint,
+  seedBlueprintWorkspaces,
   seedDefaultWorkspace,
   topUpDefaultWorkspace,
   markDefaultWorkspaceDeclined,
@@ -252,6 +247,14 @@ const WORKSPACE_SUBCOMMANDS: {
     usage: "code [n]",
     lines: ["open it in your editor (VS Code: a .code-workspace)"],
   },
+  {
+    name: "seed",
+    usage: "seed",
+    lines: [
+      "fill workspaces from the distribution's blueprint",
+      "(defaults.workspace / defaults.workspaces), all managed",
+    ],
+  },
 ];
 
 const COMMAND_HELP: Record<string, { usage: string; lines: string[] }> = {
@@ -486,8 +489,6 @@ function printValidation(
   layer?: string,
 ): void {
   const tag = layer ? `${layer}, ` : "";
-  const plural = (n: number, word: string): string =>
-    `${n} ${word}${n === 1 ? "" : "s"}`;
   if (result.valid && result.warnings.length === 0) {
     console.log(
       chalk.green(`  ✓  ${label}`) +
@@ -2274,7 +2275,7 @@ class DenCLI {
     }
     console.log(
       chalk.cyan(
-        `\n  ${only ? "Application" : "Workspace-wide"} up — ${chalk.bold(String(order.length))} systems`,
+        `\n  ${only ? "Application" : "Workspace-wide"} up — ${chalk.bold(String(order.length))} ${noun(order.length, "system")}`,
       ),
     );
     console.log(chalk.gray(`  Order: ${order.join(" → ")}\n`));
@@ -2335,7 +2336,7 @@ class DenCLI {
     const order = [...target.rawOrder].reverse();
     console.log(
       chalk.cyan(
-        `\n  ${only ? "Application" : "Workspace-wide"} down — ${chalk.bold(String(order.length))} systems`,
+        `\n  ${only ? "Application" : "Workspace-wide"} down — ${chalk.bold(String(order.length))} ${noun(order.length, "system")}`,
       ),
     );
     console.log(chalk.gray(`  Order: ${order.join(" → ")}\n`));
@@ -2483,36 +2484,55 @@ class DenCLI {
   }
 
   /**
-   * Seed (or reset) the default workspace from the committed blueprint
-   * (config/den.yml `defaults.workspace`), all repos managed. Prints
-   * clear guidance and, on a TTY, asks first. `reason: "auto"` is the one-time
-   * offer on a fresh clone; `reason: "init"` is the explicit `den init`.
-   * Returns true if the workspace was seeded.
+   * Seed (or reset) the blueprint's workspaces from the committed config:
+   * `defaults.workspace` fills `default`; `defaults.workspaces` creates each
+   * named workspace, activates them all and focuses the marked one. All
+   * repos managed. Prints clear guidance and, on a TTY, asks first.
+   * `reason: "auto"` is the one-time offer on a genuine fresh setup (TTY
+   * only: see ensureWorkspaceSeeded); `reason: "init"` is the explicit
+   * `<cli> workspace seed` / `<cli> init` in the root. Returns true if seeded.
    */
   private async seedDefaultWorkspaceFlow(
     reason: "auto" | "init",
   ): Promise<boolean> {
-    const repos = defaultWorkspaceRepos();
-    if (repos.length === 0) {
+    const bps = blueprintWorkspaces();
+    if (bps.length === 0) {
       if (reason === "init") {
         console.log(
           chalk.yellow(
-            `\n  No defaults.workspace.repos in ${product().configFile} — nothing to seed.\n`,
+            `\n  No defaults.workspace.repos or defaults.workspaces in ${product().configFile} — nothing to seed.\n`,
           ),
         );
       }
       return false;
     }
+    const multi = isMultiBlueprint();
+    // A repeat seed: say so, and touch nothing.
+    if (blueprintAlreadySeeded()) {
+      console.log(
+        chalk.green(
+          multi
+            ? `\n  ✓ ${plural(bps.length, "workspace")} already seeded (${bps.map((b) => b.name).join(", ")}): nothing changed.\n`
+            : `\n  ✓ Default workspace already seeded — ${plural(bps[0].repos.length, "repo")} (managed): nothing changed.\n`,
+        ),
+      );
+      return false;
+    }
     const willReset = defaultWorkspaceHasServices();
     const interactive = !!(process.stdin.isTTY && process.stdout.isTTY);
 
-    console.log(
-      chalk.cyan(`\n  Default workspace — ${repos.length} repos, all managed:`),
-    );
-    console.log(chalk.gray(`    ${repos.join(", ")}`));
+    for (const bp of bps) {
+      const label = multi ? `Workspace ${bp.name}` : "Default workspace";
+      console.log(
+        chalk.cyan(
+          `\n  ${label} — ${plural(bp.repos.length, "repo")}, all managed:`,
+        ),
+      );
+      console.log(chalk.gray(`    ${bp.repos.join(", ")}`));
+    }
     console.log(
       chalk.gray(
-        `  ${product().title} clones + tracks them on main under ${product().servicesDir}/. Switch any`,
+        `  ${product().title} clones + tracks them on their branch under ${product().servicesDir}/. Switch any`,
       ),
     );
     console.log(
@@ -2522,16 +2542,17 @@ class DenCLI {
     );
 
     if (interactive) {
+      const what = multi ? "these workspaces" : "the default workspace";
       const question = willReset
-        ? "  Reset the default workspace to this shipped set?"
-        : "  Seed the default workspace now?";
+        ? `  Reset ${what} to this shipped set?`
+        : `  Seed ${what} now?`;
       const ok = await cliPrompts.confirm(question, !willReset);
       if (!ok) {
         if (reason === "auto") {
           markDefaultWorkspaceDeclined(); // don't ask again
           console.log(
             chalk.gray(
-              `  Skipped — run \`${product().cli} init\` to set it up later.\n`,
+              `  Skipped — run \`${product().cli} workspace seed\` to set it up later.\n`,
             ),
           );
         } else {
@@ -2541,10 +2562,21 @@ class DenCLI {
       }
     }
 
+    if (multi) {
+      const seeded = seedBlueprintWorkspaces();
+      const focus = readWorkspacesFile().focus;
+      console.log(
+        chalk.green(
+          `  ✓ ${plural(seeded.length, "workspace")} ${willReset ? "reset to the blueprint" : "ready"} (${seeded.map((w) => w.name).join(", ")}), all active; focus: ${focus}. ` +
+            `Run \`${product().cli} up <repo>\` to bring up its closure.\n`,
+        ),
+      );
+      return true;
+    }
     const seeded = seedDefaultWorkspace();
     console.log(
       chalk.green(
-        `  ✓ Default workspace ready — ${seeded.length} repos (managed). ` +
+        `  ✓ Default workspace ${willReset ? "reset to the blueprint" : "ready"} — ${plural(seeded.length, "repo")} (managed). ` +
           `Run \`${product().cli} up <repo>\` to bring up its closure.\n`,
       ),
     );
@@ -2552,20 +2584,29 @@ class DenCLI {
   }
 
   /**
-   * One-time offer to seed the default workspace on a fresh clone; afterwards
-   * keep it converged on the blueprint (repos added to defaults later — e.g.
-   * tasks-api — join the existing workspace managed).
+   * On a genuine fresh setup (nothing but an empty, never-seeded `default`),
+   * offer to seed from the blueprint: on a TTY, ask; otherwise print a
+   * one-line hint and change nothing. Afterwards keep a lone `default`
+   * converged on the blueprint (repos added to defaults later join it
+   * managed); never once the user has other workspaces.
    */
   private async ensureWorkspaceSeeded(): Promise<void> {
     if (defaultWorkspaceNeedsSeeding()) {
-      await this.seedDefaultWorkspaceFlow("auto");
+      if (process.stdin.isTTY && process.stdout.isTTY) {
+        await this.seedDefaultWorkspaceFlow("auto");
+      } else {
+        const hint = isMultiBlueprint()
+          ? "no workspaces yet: run `{cli} workspace seed` to create them from the blueprint"
+          : "default workspace is empty: run `{cli} workspace seed` to fill it from the blueprint";
+        console.error(chalk.gray(`  ${hint.replace("{cli}", product().cli)}`));
+      }
       return;
     }
     const added = topUpDefaultWorkspace();
     if (added.length > 0) {
       console.log(
         chalk.gray(
-          `  default workspace: added standard repo(s) ${added.join(", ")} (managed)`,
+          `  default workspace: added standard ${noun(added.length, "repo")} ${added.join(", ")} (managed)`,
         ),
       );
     }
@@ -3627,6 +3668,10 @@ class DenCLI {
         );
         break;
       }
+      case "seed": {
+        await this.seedDefaultWorkspaceFlow("init");
+        break;
+      }
       case "create": {
         const name =
           args[1] ??
@@ -3718,7 +3763,7 @@ class DenCLI {
       default:
         console.log(
           chalk.gray(
-            `Usage: ${product().cli} workspace <list|activate|deactivate|focus|use|create|delete|code> [name]`,
+            `Usage: ${product().cli} workspace <${WORKSPACE_SUBCOMMANDS.map((c) => c.name).join("|")}> [name]`,
           ),
         );
     }
@@ -3761,7 +3806,7 @@ class DenCLI {
     if (missing.length > 0) {
       console.log(
         chalk.cyan(
-          `\n  Cloning ${missing.length} managed repo(s) not on disk yet: ${missing.join(", ")}`,
+          `\n  Cloning ${plural(missing.length, "managed repo")} not on disk yet: ${missing.join(", ")}`,
         ),
       );
       await this.ensureManagedClonesFor(missing);