diff --git a/README.md b/README.md
index f7c0434..f4d3818 100644
--- a/README.md
+++ b/README.md
@@ -15,6 +15,14 @@ cc-timer "2h10m" "Explore if this is this the real life? "
 - Keep pending jobs in a JSON state file so they can be listed or canceled later.
 - Work the same way on macOS, Linux, and Windows without shell-specific tricks.
 
+## Glossary
+
+`cc-timer` uses three related terms consistently:
+
+- **Task** — one unit of work you provide (a positional argument, a `--task`, or a line from `--file`). Each task becomes a single `claude --bg <task>` invocation.
+- **Job** — the scheduled record that groups one or more tasks under a single dispatch time. Jobs are what you `list` and `cancel`; each has an id like `ct_9f2aXY`.
+- **Agent** — the Claude Code background agent a task turns into once the job is dispatched. After dispatch, agents appear in `claude agents` and are managed there, not by `cc-timer`.
+
 ## Install
 
 Install globally from npm:
@@ -53,7 +61,7 @@ cc-timer "45m" "Investigate this landslide, why no escape from reality"
 ```
 
 ```text
-[Success] Scheduled 1 task to run in 45 minutes (2700 seconds).
+[Success] Scheduled 1 task to run in 45 minutes (2,700 seconds).
 Dispatch time: 2026-05-18 15:42:00 local time
 Tasks:
 - Investigate this landslide, why no escape from reality
@@ -174,6 +182,18 @@ cc-timer "2h" \
   --dry-run
 ```
 
+```text
+[Dry-run] Would schedule 2 tasks to run in 2 hours (7,200 seconds).
+Dispatch time: 2026-05-18 17:42:00 local time
+Commands:
+- claude --bg "Ping mama, ooh (any way the wind blows)"
+- claude --bg "Respawn I don't wanna die"
+
+No job was created.
+```
+
+The dry run prints the exact shell-quoted `claude` invocations under `Commands:`. Add `--json` to get the same preview as a `commands` array.
+
 ## Listing pending jobs
 
 ```bash
@@ -214,16 +234,16 @@ Cancellation marks the job state before terminating the worker, so a wake-up tha
 
 `cc-timer [delay] [tasks...]` — schedule new agents.
 
-| Option                        | Description                                                      |
-| ----------------------------- | ---------------------------------------------------------------- |
-| `--task <text>`               | Add one task. Repeatable.                                        |
-| `--file <path>`               | Read tasks from a text file, one per line.                       |
-| `--at <time>`                 | Use an exact local time instead of `delay`.                      |
-| `--dry-run`                   | Print the plan without creating a job.                           |
-| `--claude-bin <path-or-name>` | Override the `claude` executable. Default: `claude`.             |
-| `--cwd <path>`                | Working directory for dispatched commands. Default: current dir. |
-| `--log-file <path>`           | Explicit log output file.                                        |
-| `--json`                      | Machine-readable JSON output.                                    |
+| Option                        | Description                                                          |
+| ----------------------------- | -------------------------------------------------------------------- |
+| `--task <text>`               | Add one task. Repeatable.                                            |
+| `--file <path>`               | Read tasks from a text file, one per line.                           |
+| `--at <time>`                 | Schedule at an exact local time, e.g. `17:30` or `2026-05-19 09:00`. |
+| `--dry-run`                   | Show the planned schedule without creating a job.                    |
+| `--claude-bin <path-or-name>` | Override the `claude` executable. Default: `claude`.                 |
+| `--cwd <path>`                | Working directory for dispatched commands. Default: current dir.     |
+| `--log-file <path>`           | Explicit log output file.                                            |
+| `--json`                      | Machine-readable JSON output.                                        |
 
 Anything after a standalone `--` is forwarded verbatim to `claude`.
 
diff --git a/src/claude/adapter.ts b/src/claude/adapter.ts
index 77350cd..99b3b6b 100644
--- a/src/claude/adapter.ts
+++ b/src/claude/adapter.ts
@@ -3,6 +3,7 @@
  * without affecting the rest of the codebase.
  */
 import { CcTimerError } from "../errors.js";
+import { Label } from "../labels.js";
 
 export interface ClaudeCommand {
   args: string[];
@@ -26,7 +27,7 @@ export function validateClaudeArgs(args: readonly string[]): void {
     const reason = RESERVED_FLAGS[head];
     if (reason) {
       throw new CcTimerError(
-        `[Error] Cannot forward ${head} to claude — ${reason} Remove it from the args after \`--\`.`,
+        `${Label.Error} Cannot forward ${head} to claude — ${reason} Remove it from the args after \`--\`.`,
       );
     }
   }
diff --git a/src/cli.ts b/src/cli.ts
index 5c6e7fb..fa17514 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -1,19 +1,65 @@
 #!/usr/bin/env node
-import { Command, Option } from "commander";
+import { Command, CommanderError, Option } from "commander";
 import { createRequire } from "node:module";
 import { runCancel, runCancelAll } from "./commands/cancel.js";
 import { runList } from "./commands/list.js";
 import { runSchedule } from "./commands/schedule.js";
 import { CcTimerError, formatCliError } from "./errors.js";
+import { Label } from "./labels.js";
 
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json") as { version: string };
 
+const SUBCOMMANDS = ["list", "cancel"] as const;
+
 function die(err: unknown): never {
   process.stderr.write(`${formatCliError(err)}\n`);
   process.exit(1);
 }
 
+/**
+ * Route commander's own parse errors (unknown option, invalid argument, …)
+ * through the same `[Error]` + prelude rendering as everything else, instead of
+ * commander's lowercase `error: …` + usage dump. Help/version output has already
+ * been printed at this point and carries exit code 0, so we exit cleanly.
+ */
+function handleParseError(err: unknown): never {
+  if (err instanceof CommanderError) {
+    if (err.exitCode === 0) process.exit(0);
+    const message = err.message.replace(/^error:\s*/i, "");
+    process.stderr.write(`${formatCliError(message)}\n`);
+    process.exit(err.exitCode || 1);
+  }
+  die(err);
+}
+
+/** Levenshtein distance, used to spot mistyped subcommands. */
+function editDistance(a: string, b: string): number {
+  const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let diag = prev[0];
+    prev[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const tmp = prev[j];
+      prev[j] =
+        a[i - 1] === b[j - 1] ? diag : 1 + Math.min(prev[j], prev[j - 1], diag);
+      diag = tmp;
+    }
+  }
+  return prev[b.length];
+}
+
+/**
+ * The default action owns `[items...]`, so a mistyped subcommand like `lst` is
+ * parsed as a delay and fails with a confusing "Invalid delay". Detect a
+ * near-miss against the real subcommands and suggest it instead.
+ */
+function suggestSubcommand(token: string): string | undefined {
+  const word = token.toLowerCase();
+  if (word.includes(" ")) return undefined;
+  return SUBCOMMANDS.find((cmd) => editDistance(word, cmd) <= 2);
+}
+
 /**
  * Split argv at the first standalone `--` separator. Everything after is
  * collected as passthrough args for the underlying `claude` invocation.
@@ -31,54 +77,65 @@ function splitPassthrough(argv: string[]): {
 
 function buildProgram(claudeArgs: string[]): Command {
   const program = new Command();
+  // Set before adding subcommands so they inherit these settings and their
+  // parse errors flow through handleParseError too.
+  program.exitOverride();
+  program.configureOutput({ writeErr: () => {} });
   program
     .name("cc-timer")
     .description(
-      "Schedule Claude Code background agents after a delay or at a specific time.",
+      "Schedule Claude Code background agents after a delay or at a specific local time.",
     )
-    .version(packageJson.version)
-    .showHelpAfterError();
+    .version(packageJson.version);
 
   // Default action: schedule new agents.
   program
     .argument(
       "[items...]",
-      "Delay followed by tasks, or just tasks when using --at",
+      "Delay followed by tasks, or just tasks when using --at.",
     )
     .option(
       "--task <text>",
-      "Add one task (repeatable)",
+      "Add one task. Repeatable.",
       (val: string, prev: string[]) => {
         prev.push(val);
         return prev;
       },
       [] as string[],
     )
-    .option("--file <path>", "Read tasks from a text file")
+    .option("--file <path>", "Read tasks from a text file, one per line.")
     .option(
       "--at <time>",
-      'Schedule at an exact local time, e.g. "17:30" or "2026-05-19 09:00"',
+      'Schedule at an exact local time, e.g. "17:30" or "2026-05-19 09:00".',
     )
     .option(
       "--dry-run",
-      "Show the planned schedule without creating a job",
+      "Show the planned schedule without creating a job.",
       false,
     )
     .option(
       "--claude-bin <path-or-name>",
-      "Claude CLI executable name or path",
+      "Override the claude executable. Default: claude.",
       "claude",
     )
     .option(
       "--cwd <path>",
-      "Working directory for dispatched commands",
+      "Working directory for dispatched commands. Default: current dir.",
       process.cwd(),
     )
-    .option("--log-file <path>", "Explicit log output file")
-    .option("--json", "Machine-readable JSON output", false)
+    .option("--log-file <path>", "Explicit log output file.")
+    .option("--json", "Machine-readable JSON output.", false)
     .action(async (items: string[], options) => {
       try {
         const scheduleItems = items ?? [];
+        if (!options.at && scheduleItems.length > 0) {
+          const suggestion = suggestSubcommand(scheduleItems[0]);
+          if (suggestion) {
+            throw new CcTimerError(
+              `${Label.Error} Unknown command "${scheduleItems[0]}". Did you mean "${suggestion}"?`,
+            );
+          }
+        }
         const delay = options.at ? undefined : scheduleItems[0];
         const positional = options.at ? scheduleItems : scheduleItems.slice(1);
         const res = await runSchedule({
@@ -103,9 +160,9 @@ function buildProgram(claudeArgs: string[]): Command {
   program
     .command("list")
     .description("List pending jobs.")
-    .option("--verbose", "Show task text, PID, and dispatch details", false)
-    .option("--json", "Machine-readable JSON output", false)
-    .option("--all", "Include dispatched/canceled history", false)
+    .option("--verbose", "Show task text, PID, and dispatch details.", false)
+    .option("--json", "Machine-readable JSON output.", false)
+    .option("--all", "Include dispatched/canceled history.", false)
     .action(async (options) => {
       try {
         const out = await runList({
@@ -122,19 +179,19 @@ function buildProgram(claudeArgs: string[]): Command {
   program
     .command("cancel [id]")
     .description("Cancel a pending job, or all pending jobs with --all.")
-    .option("--all", "Cancel every pending job", false)
-    .option("--json", "Machine-readable JSON output", false)
+    .option("--all", "Cancel every pending job.", false)
+    .option("--json", "Machine-readable JSON output.", false)
     .action(async (id: string | undefined, options) => {
       try {
         const all = Boolean(options.all);
         if (all && id) {
           throw new CcTimerError(
-            "[Error] Pass either an id or --all, not both.",
+            `${Label.Error} Pass either an id or --all, not both.`,
           );
         }
         if (!all && !id) {
           throw new CcTimerError(
-            "[Error] Provide a job id or use --all to cancel every pending job.",
+            `${Label.Error} Provide a job id or use --all to cancel every pending job.`,
           );
         }
         const res = all
@@ -153,4 +210,4 @@ function buildProgram(claudeArgs: string[]): Command {
 
 const { head, claudeArgs } = splitPassthrough(process.argv);
 const program = buildProgram(claudeArgs);
-program.parseAsync(head).catch(die);
+program.parseAsync(head).catch(handleParseError);
diff --git a/src/commands/cancel.ts b/src/commands/cancel.ts
index 2b54b27..9b2e8ec 100644
--- a/src/commands/cancel.ts
+++ b/src/commands/cancel.ts
@@ -2,6 +2,7 @@ import { CcTimerError } from "../errors.js";
 import { isProcessAlive, terminateProcess } from "../scheduler/process.js";
 import { getJob, listPending, updateJob } from "../state/jobStore.js";
 import { JobRecord } from "../state/schema.js";
+import { Label } from "../labels.js";
 
 export interface CancelOptions {
   id: string;
@@ -46,11 +47,22 @@ async function cancelJob(job: JobRecord): Promise<void> {
 export async function runCancel(opts: CancelOptions): Promise<CancelResult> {
   const job = await getJob(opts.id);
   if (!job) {
-    throw new CcTimerError(`[Error] Unknown job id "${opts.id}".`);
+    throw new CcTimerError(`${Label.Error} Unknown job id "${opts.id}".`);
   }
 
-  if (job.status === "dispatched") {
-    const msg = `[Info] Job ${job.id} already dispatched. Any created Claude agents must be managed separately.`;
+  // Terminal states share one structurally parallel phrasing:
+  // "Job <id> already <state>; nothing to cancel."
+  const terminal: Record<string, CancelResult["status"]> = {
+    dispatched: "already-dispatched",
+    canceled: "already-canceled",
+    failed: "already-failed",
+  };
+  if (job.status in terminal) {
+    const suffix =
+      job.status === "dispatched"
+        ? " Any created Claude agents must be managed separately."
+        : "";
+    const msg = `${Label.Info} Job ${job.id} already ${job.status}; nothing to cancel.${suffix}`;
     return {
       output: opts.json
         ? JSON.stringify(
@@ -59,38 +71,14 @@ export async function runCancel(opts: CancelOptions): Promise<CancelResult> {
             2,
           )
         : msg,
-      status: "already-dispatched",
-    };
-  }
-  if (job.status === "canceled") {
-    return {
-      output: opts.json
-        ? JSON.stringify(
-            { id: job.id, status: job.status, action: "noop" },
-            null,
-            2,
-          )
-        : `[Info] Job ${job.id} was already canceled.`,
-      status: "already-canceled",
-    };
-  }
-  if (job.status === "failed") {
-    return {
-      output: opts.json
-        ? JSON.stringify(
-            { id: job.id, status: job.status, action: "noop" },
-            null,
-            2,
-          )
-        : `[Info] Job ${job.id} already failed; nothing to cancel.`,
-      status: "already-failed",
+      status: terminal[job.status],
     };
   }
 
   // Mark canceled before attempting termination so a racing wake-up sees the new state.
   await cancelJob(job);
 
-  const msg = `[Success] Canceled job ${job.id}.`;
+  const msg = `${Label.Success} Canceled job ${job.id}.`;
   return {
     output: opts.json
       ? JSON.stringify(
@@ -113,7 +101,7 @@ export async function runCancelAll(
     return {
       output: opts.json
         ? JSON.stringify({ canceled: 0, ids: [], action: "noop" }, null, 2)
-        : "[Info] No pending jobs to cancel.",
+        : `${Label.Info} No pending jobs to cancel.`,
       canceledIds: [],
     };
   }
diff --git a/src/commands/list.ts b/src/commands/list.ts
index 51da2e9..557e898 100644
--- a/src/commands/list.ts
+++ b/src/commands/list.ts
@@ -4,6 +4,13 @@ import {
   formatDurationShort,
   formatLocalTimestamp,
 } from "../time/formatDuration.js";
+import {
+  padWidth,
+  sanitizeCell,
+  stringWidth,
+  truncateWidth,
+} from "../util/textWidth.js";
+import { Label } from "../labels.js";
 
 export interface ListOptions {
   verbose: boolean;
@@ -13,18 +20,25 @@ export interface ListOptions {
 }
 
 const MESSAGE_PREVIEW_MAX = 48;
-
-function truncate(text: string, max: number): string {
-  if (text.length <= max) return text;
-  return `${text.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
-}
+// Always keep at least this many columns for the first task so a huge task
+// count can't collapse the preview to a bare ellipsis.
+const MESSAGE_PREVIEW_MIN = 8;
 
 function formatMessagePreview(tasks: string[]): string {
   const [firstTask = "", ...rest] = tasks;
   if (!firstTask) return "";
 
   const suffix = rest.length > 0 ? ` (+${rest.length} more)` : "";
-  return `${truncate(firstTask, MESSAGE_PREVIEW_MAX - suffix.length)}${suffix}`;
+  const budget = Math.max(
+    MESSAGE_PREVIEW_MIN,
+    MESSAGE_PREVIEW_MAX - stringWidth(suffix),
+  );
+  return `${truncateWidth(sanitizeCell(firstTask), budget)}${suffix}`;
+}
+
+function dueIn(dueAt: string, now: number): string {
+  const dueInSec = Math.round((new Date(dueAt).getTime() - now) / 1000);
+  return dueInSec > 0 ? formatDurationShort(dueInSec) : "now";
 }
 
 export async function runList(opts: ListOptions): Promise<string> {
@@ -54,7 +68,9 @@ export async function runList(opts: ListOptions): Promise<string> {
   }
 
   if (filtered.length === 0) {
-    return opts.all ? "No jobs." : "No pending jobs.";
+    return opts.all
+      ? `${Label.Info} No jobs.`
+      : `${Label.Info} No pending jobs.`;
   }
 
   if (opts.verbose) {
@@ -63,13 +79,14 @@ export async function runList(opts: ListOptions): Promise<string> {
       const lines: string[] = [];
       lines.push(j.id);
       lines.push(`  Status: ${j.status}`);
+      lines.push(`  Due in: ${dueIn(j.dueAt, now)}`);
       if (j.schedulerPid != null) lines.push(`  PID: ${j.schedulerPid}`);
       lines.push(
         `  Dispatch time: ${formatLocalTimestamp(new Date(j.dueAt))} local time`,
       );
       lines.push("  Tasks:");
-      for (const t of j.tasks) lines.push(`  - ${t}`);
-      if (j.error) lines.push(`  Error: ${j.error}`);
+      for (const t of j.tasks) lines.push(`  - ${sanitizeCell(t)}`);
+      if (j.error) lines.push(`  Error: ${sanitizeCell(j.error)}`);
       blocks.push(lines.join("\n"));
     }
     return blocks.join("\n\n");
@@ -77,32 +94,27 @@ export async function runList(opts: ListOptions): Promise<string> {
 
   const header = [
     "ID",
-    "Due In",
-    "Dispatch Time",
+    "Due in",
+    "Dispatch time",
     "Message",
     "Tasks",
     "Status",
   ];
-  const rows = filtered.map((j) => {
-    const dueInSec = Math.round((new Date(j.dueAt).getTime() - now) / 1000);
-    return [
-      j.id,
-      dueInSec > 0 ? formatDurationShort(dueInSec) : "now",
-      formatLocalTimestamp(new Date(j.dueAt)),
-      formatMessagePreview(j.tasks),
-      String(j.tasks.length),
-      j.status,
-    ];
-  });
+  const rows = filtered.map((j) => [
+    j.id,
+    dueIn(j.dueAt, now),
+    formatLocalTimestamp(new Date(j.dueAt)),
+    formatMessagePreview(j.tasks),
+    String(j.tasks.length),
+    j.status,
+  ]);
 
   const widths = header.map((h, i) =>
-    Math.max(h.length, ...rows.map((r) => r[i].length)),
+    Math.max(stringWidth(h), ...rows.map((r) => stringWidth(r[i]))),
   );
-  const pad = (s: string, w: number) =>
-    s + " ".repeat(Math.max(0, w - s.length));
   const fmt = (cells: string[]) =>
     cells
-      .map((c, i) => pad(c, widths[i]))
+      .map((c, i) => padWidth(c, widths[i]))
       .join("  ")
       .trimEnd();
 
diff --git a/src/commands/loadTasks.ts b/src/commands/loadTasks.ts
index f5baf7f..4e871b5 100644
--- a/src/commands/loadTasks.ts
+++ b/src/commands/loadTasks.ts
@@ -1,5 +1,6 @@
 import { promises as fs } from "node:fs";
 import { CcTimerError } from "../errors.js";
+import { Label } from "../labels.js";
 
 export interface TaskSources {
   positional: string[];
@@ -28,7 +29,7 @@ export async function collectTasks(sources: TaskSources): Promise<string[]> {
       const code = (err as NodeJS.ErrnoException)?.code;
       if (code === "ENOENT") {
         throw new CcTimerError(
-          `[Error] Task file not found: ${sources.filePath}`,
+          `${Label.Error} Task file not found: ${sources.filePath}`,
         );
       }
       throw err;
diff --git a/src/commands/schedule.ts b/src/commands/schedule.ts
index 41faa0c..b7f9832 100644
--- a/src/commands/schedule.ts
+++ b/src/commands/schedule.ts
@@ -16,6 +16,7 @@ import {
 import { parseAt } from "../time/parseAt.js";
 import { parseDelay } from "../time/parseDelay.js";
 import { collectTasks } from "./loadTasks.js";
+import { Label } from "../labels.js";
 
 export interface ScheduleOptions {
   delay?: string;
@@ -47,12 +48,12 @@ async function buildPlan(opts: ScheduleOptions): Promise<Plan> {
   }
   if (opts.delay && opts.at) {
     throw new CcTimerError(
-      "[Error] Use either a positional delay or --at, not both.",
+      `${Label.Error} Use either a positional delay or --at, not both.`,
     );
   }
   if (!opts.delay && !opts.at) {
     throw new CcTimerError(
-      '[Error] Missing delay. Provide a delay like "45m" or use --at "17:30".',
+      `${Label.Error} Missing delay. Provide a delay like "45m" or use --at "17:30".`,
     );
   }
 
@@ -82,7 +83,7 @@ async function buildPlan(opts: ScheduleOptions): Promise<Plan> {
   });
   if (tasks.length === 0) {
     throw new CcTimerError(
-      "[Error] No tasks provided. Add a quoted task, --task, or --file.",
+      `${Label.Error} No tasks provided. Add a quoted task, --task, or --file.`,
     );
   }
 
@@ -102,14 +103,23 @@ interface ScheduleResult {
   dryRun: boolean;
 }
 
+/**
+ * "to run in 2 hours (7,200 seconds)", or "to run now" when the delay rounds to
+ * zero so we never emit the redundant "in 0 seconds (0 seconds)".
+ */
+function formatRunIn(delaySeconds: number): string {
+  if (delaySeconds <= 0) return "to run now";
+  const dur = formatDurationLong(delaySeconds);
+  return `to run in ${dur} (${delaySeconds.toLocaleString("en-US")} seconds)`;
+}
+
 function buildSuccessOutput(plan: Plan): string {
   const count = plan.tasks.length;
   const noun = count === 1 ? "task" : "tasks";
-  const dur = formatDurationLong(plan.delaySeconds);
   const dueLocal = formatLocalTimestamp(plan.dueAt);
   const lines: string[] = [];
   lines.push(
-    `[Success] Scheduled ${count} ${noun} to run in ${dur} (${plan.delaySeconds} seconds).`,
+    `${Label.Success} Scheduled ${count} ${noun} ${formatRunIn(plan.delaySeconds)}.`,
   );
   lines.push(`Dispatch time: ${dueLocal} local time`);
   lines.push("Tasks:");
@@ -123,24 +133,27 @@ function buildSuccessOutput(plan: Plan): string {
 function buildDryRunOutput(plan: Plan, opts: ScheduleOptions): string {
   const count = plan.tasks.length;
   const noun = count === 1 ? "task" : "tasks";
-  const dur = formatDurationLong(plan.delaySeconds);
   const dueLocal = formatLocalTimestamp(plan.dueAt);
   const lines: string[] = [];
   lines.push(
-    `[Dry run] Would schedule ${count} ${noun} to run in ${dur} (${plan.delaySeconds} seconds).`,
+    `${Label.DryRun} Would schedule ${count} ${noun} ${formatRunIn(plan.delaySeconds)}.`,
   );
   lines.push(`Dispatch time: ${dueLocal} local time`);
-  lines.push("Tasks:");
-  const extra = opts.claudeArgs ?? [];
-  for (const t of plan.tasks) {
-    const cmd = newAgentCommand(t, extra);
-    lines.push(`- ${previewCommand(opts.claudeBin, cmd)}`);
-  }
+  lines.push("Commands:");
+  for (const cmd of previewCommands(plan, opts)) lines.push(`- ${cmd}`);
   lines.push("");
   lines.push("No job was created.");
   return lines.join("\n");
 }
 
+/** Shell-quoted `claude` invocations the dry-run would dispatch, one per task. */
+function previewCommands(plan: Plan, opts: ScheduleOptions): string[] {
+  const extra = opts.claudeArgs ?? [];
+  return plan.tasks.map((t) =>
+    previewCommand(opts.claudeBin, newAgentCommand(t, extra)),
+  );
+}
+
 export async function runSchedule(
   opts: ScheduleOptions,
 ): Promise<ScheduleResult> {
@@ -154,6 +167,7 @@ export async function runSchedule(
             dueAt: plan.dueAt.toISOString(),
             delaySeconds: plan.delaySeconds,
             tasks: plan.tasks,
+            commands: previewCommands(plan, opts),
           },
           null,
           2,
@@ -193,7 +207,7 @@ export async function runSchedule(
     // gives the user immediate feedback.
   } catch (err) {
     throw new CcTimerError(
-      `[Error] Failed to start scheduler: ${err instanceof Error ? err.message : String(err)}`,
+      `${Label.Error} Failed to start scheduler: ${err instanceof Error ? err.message : String(err)}`,
     );
   }
 
diff --git a/src/errors.ts b/src/errors.ts
index 540542e..35e9134 100644
--- a/src/errors.ts
+++ b/src/errors.ts
@@ -1,3 +1,4 @@
+import { Label } from "./labels.js";
 export class CcTimerError extends Error {
   constructor(message: string) {
     super(message);
@@ -49,7 +50,9 @@ function withPrelude(message: string): string {
 }
 
 function ensureErrorLabel(message: string): string {
-  return message.startsWith("[Error]") ? message : `[Error] ${message}`;
+  return message.startsWith(Label.Error)
+    ? message
+    : `${Label.Error} ${message}`;
 }
 
 export function formatCliError(err: unknown): string {
@@ -57,7 +60,6 @@ export function formatCliError(err: unknown): string {
 }
 
 export function formatWorkerError(message: string): string {
-  return withPrelude(
-    message.startsWith("worker:") ? message : `worker: ${message}`,
-  );
+  const tagged = message.startsWith("worker:") ? message : `worker: ${message}`;
+  return withPrelude(ensureErrorLabel(tagged));
 }
diff --git a/src/labels.ts b/src/labels.ts
new file mode 100644
index 0000000..97b3d6d
--- /dev/null
+++ b/src/labels.ts
@@ -0,0 +1,11 @@
+/**
+ * Single-word status labels that prefix user-facing terminal output. Keeping
+ * them in one place makes the vocabulary consistent and greppable across
+ * commands and error paths.
+ */
+export enum Label {
+  Error = "[Error]",
+  Info = "[Info]",
+  Success = "[Success]",
+  DryRun = "[Dry-run]",
+}
diff --git a/src/time/parseAt.ts b/src/time/parseAt.ts
index fbac822..bb0cca8 100644
--- a/src/time/parseAt.ts
+++ b/src/time/parseAt.ts
@@ -1,4 +1,5 @@
 import { CcTimerError } from "../errors.js";
+import { Label } from "../labels.js";
 
 export interface ParsedAt {
   dueAt: Date;
@@ -13,7 +14,7 @@ const DATETIME_RE =
 function normalizeHour(raw: string, hour: number, ampm?: string): number {
   if (ampm) {
     if (hour < 1 || hour > 12) {
-      throw new CcTimerError(`[Error] Invalid time "${raw}".`);
+      throw new CcTimerError(`${Label.Error} Invalid time "${raw}".`);
     }
     if (ampm === "pm" && hour !== 12) return hour + 12;
     if (ampm === "am" && hour === 12) return 0;
@@ -21,7 +22,7 @@ function normalizeHour(raw: string, hour: number, ampm?: string): number {
   }
 
   if (hour > 23) {
-    throw new CcTimerError(`[Error] Invalid time "${raw}".`);
+    throw new CcTimerError(`${Label.Error} Invalid time "${raw}".`);
   }
   return hour;
 }
@@ -33,7 +34,7 @@ function buildNextOccurrence(
   minute: number,
 ): ParsedAt {
   if (minute > 59) {
-    throw new CcTimerError(`[Error] Invalid time "${raw}".`);
+    throw new CcTimerError(`${Label.Error} Invalid time "${raw}".`);
   }
 
   const candidate = new Date(
@@ -59,13 +60,13 @@ function buildNextOccurrence(
 export function parseAt(raw: string, now: Date = new Date()): ParsedAt {
   if (raw == null) {
     throw new CcTimerError(
-      '[Error] Invalid time "". Try "17:30" or "2026-05-19 09:00".',
+      `${Label.Error} Invalid time "". Try "17:30" or "2026-05-19 09:00".`,
     );
   }
   const input = String(raw).trim();
   if (!input) {
     throw new CcTimerError(
-      '[Error] Invalid time "". Try "17:30" or "2026-05-19 09:00".',
+      `${Label.Error} Invalid time "". Try "17:30" or "2026-05-19 09:00".`,
     );
   }
 
@@ -89,10 +90,10 @@ export function parseAt(raw: string, now: Date = new Date()): ParsedAt {
       due.getHours() !== Number(h) ||
       due.getMinutes() !== Number(mi)
     ) {
-      throw new CcTimerError(`[Error] Invalid time "${raw}".`);
+      throw new CcTimerError(`${Label.Error} Invalid time "${raw}".`);
     }
     if (due.getTime() <= now.getTime()) {
-      throw new CcTimerError(`[Error] Time "${raw}" is in the past.`);
+      throw new CcTimerError(`${Label.Error} Time "${raw}" is in the past.`);
     }
     return { dueAt: due, input };
   }
@@ -114,6 +115,6 @@ export function parseAt(raw: string, now: Date = new Date()): ParsedAt {
   }
 
   throw new CcTimerError(
-    `[Error] Invalid time "${raw}". Try "17:30", "3pm", or "2026-05-19 09:00".`,
+    `${Label.Error} Invalid time "${raw}". Try "17:30", "3pm", or "2026-05-19 09:00".`,
   );
 }
diff --git a/src/time/parseDelay.ts b/src/time/parseDelay.ts
index b06d00a..4b3aea4 100644
--- a/src/time/parseDelay.ts
+++ b/src/time/parseDelay.ts
@@ -1,4 +1,5 @@
 import { CcTimerError } from "../errors.js";
+import { Label } from "../labels.js";
 
 export interface ParsedDelay {
   ms: number;
@@ -33,13 +34,13 @@ const TOKEN_RE = /(\d+(?:\.\d+)?)\s*([a-zA-Z]+)/g;
 export function parseDelay(raw: string): ParsedDelay {
   if (raw == null) {
     throw new CcTimerError(
-      '[Error] Invalid delay "". Try values like "45m", "2h", or "2h55m".',
+      `${Label.Error} Invalid delay "". Try values like "45m", "2h", or "2h55m".`,
     );
   }
   const input = String(raw).trim();
   if (!input) {
     throw new CcTimerError(
-      '[Error] Invalid delay "". Try values like "45m", "2h", or "2h55m".',
+      `${Label.Error} Invalid delay "". Try values like "45m", "2h", or "2h55m".`,
     );
   }
 
@@ -52,7 +53,7 @@ export function parseDelay(raw: string): ParsedDelay {
     const gap = input.slice(lastIndex, m.index);
     if (gap.trim() !== "") {
       throw new CcTimerError(
-        `[Error] Invalid delay "${raw}". Try values like "45m", "2h", or "2h55m".`,
+        `${Label.Error} Invalid delay "${raw}". Try values like "45m", "2h", or "2h55m".`,
       );
     }
     tokens.push({ value: Number(m[1]), unit: m[2].toLowerCase() });
@@ -61,12 +62,12 @@ export function parseDelay(raw: string): ParsedDelay {
   // Trailing content must be empty/whitespace.
   if (input.slice(lastIndex).trim() !== "") {
     throw new CcTimerError(
-      `[Error] Invalid delay "${raw}". Try values like "45m", "2h", or "2h55m".`,
+      `${Label.Error} Invalid delay "${raw}". Try values like "45m", "2h", or "2h55m".`,
     );
   }
   if (tokens.length === 0) {
     throw new CcTimerError(
-      `[Error] Invalid delay "${raw}". Try values like "45m", "2h", or "2h55m".`,
+      `${Label.Error} Invalid delay "${raw}". Try values like "45m", "2h", or "2h55m".`,
     );
   }
 
@@ -76,14 +77,14 @@ export function parseDelay(raw: string): ParsedDelay {
     const factor = UNIT_TO_MS[tok.unit];
     if (factor === undefined) {
       throw new CcTimerError(
-        `[Error] Invalid delay "${raw}". Unknown unit "${tok.unit}". Try values like "45m", "2h", or "2h55m".`,
+        `${Label.Error} Invalid delay "${raw}". Unknown unit "${tok.unit}". Try values like "45m", "2h", or "2h55m".`,
       );
     }
     // Canonicalize each unit family to detect duplicates like "1h 2h".
     const family = String(factor);
     if (seen.has(family)) {
       throw new CcTimerError(
-        `[Error] Invalid delay "${raw}". Duplicate unit "${tok.unit}".`,
+        `${Label.Error} Invalid delay "${raw}". Duplicate unit "${tok.unit}".`,
       );
     }
     seen.add(family);
@@ -92,7 +93,7 @@ export function parseDelay(raw: string): ParsedDelay {
 
   if (!Number.isFinite(totalMs) || totalMs <= 0) {
     throw new CcTimerError(
-      `[Error] Invalid delay "${raw}". Delay must be greater than zero.`,
+      `${Label.Error} Invalid delay "${raw}". Delay must be greater than zero.`,
     );
   }
 
diff --git a/src/util/textWidth.ts b/src/util/textWidth.ts
new file mode 100644
index 0000000..e919be0
--- /dev/null
+++ b/src/util/textWidth.ts
@@ -0,0 +1,82 @@
+/**
+ * Terminal display-width helpers. `String.length` counts UTF-16 code units,
+ * which misaligns tables when task text contains wide (CJK/emoji) characters or
+ * splits surrogate pairs when truncating. These helpers measure and truncate by
+ * display columns and sanitize control characters so a single row stays a single
+ * row.
+ */
+
+/** True for characters that render two terminal columns wide. */
+function isWide(cp: number): boolean {
+  return (
+    (cp >= 0x1100 && cp <= 0x115f) || // Hangul Jamo
+    (cp >= 0x2e80 && cp <= 0x303e) || // CJK radicals, Kangxi
+    (cp >= 0x3041 && cp <= 0x33ff) || // Hiragana, Katakana, CJK symbols
+    (cp >= 0x3400 && cp <= 0x4dbf) || // CJK Unified Ideographs Ext A
+    (cp >= 0x4e00 && cp <= 0x9fff) || // CJK Unified Ideographs
+    (cp >= 0xa000 && cp <= 0xa4cf) || // Yi
+    (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables
+    (cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs
+    (cp >= 0xfe30 && cp <= 0xfe4f) || // CJK Compatibility Forms
+    (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth Forms
+    (cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth signs
+    (cp >= 0x1f000 && cp <= 0x1f0ff) || // Mahjong, dominoes, cards
+    (cp >= 0x1f300 && cp <= 0x1faff) || // emoji & pictographs
+    (cp >= 0x20000 && cp <= 0x3fffd) // CJK Unified Ideographs Ext B+
+  );
+}
+
+/** Display columns for a single code point (0 for combining/zero-width). */
+function charWidth(cp: number): number {
+  if (cp === 0) return 0;
+  if (
+    (cp >= 0x0300 && cp <= 0x036f) || // combining diacritical marks
+    (cp >= 0x200b && cp <= 0x200f) || // zero-width space .. RLM
+    cp === 0xfeff // zero-width no-break space / BOM
+  ) {
+    return 0;
+  }
+  return isWide(cp) ? 2 : 1;
+}
+
+/** Display width of a string in terminal columns. */
+export function stringWidth(input: string): number {
+  let width = 0;
+  for (const ch of input) {
+    width += charWidth(ch.codePointAt(0) ?? 0);
+  }
+  return width;
+}
+
+/**
+ * Collapse runs of control characters (including newlines and tabs) into a
+ * single space so multi-line or control-laden task text renders on one row.
+ */
+export function sanitizeCell(input: string): string {
+  // eslint-disable-next-line no-control-regex
+  return input.replace(/[\u0000-\u001f\u007f]+/g, " ");
+}
+
+/**
+ * Truncate to at most `maxWidth` display columns, appending an ellipsis when
+ * text is dropped. Iterates by code point so surrogate-pair emoji are never
+ * split mid-character.
+ */
+export function truncateWidth(input: string, maxWidth: number): string {
+  if (stringWidth(input) <= maxWidth) return input;
+  const budget = Math.max(0, maxWidth - 1); // reserve a column for the ellipsis
+  let width = 0;
+  let out = "";
+  for (const ch of input) {
+    const w = charWidth(ch.codePointAt(0) ?? 0);
+    if (width + w > budget) break;
+    width += w;
+    out += ch;
+  }
+  return `${out.trimEnd()}…`;
+}
+
+/** Right-pad a string to `width` display columns with spaces. */
+export function padWidth(input: string, width: number): string {
+  return input + " ".repeat(Math.max(0, width - stringWidth(input)));
+}
diff --git a/tests/errors.test.ts b/tests/errors.test.ts
index 1e1d390..8aa60ff 100644
--- a/tests/errors.test.ts
+++ b/tests/errors.test.ts
@@ -37,10 +37,10 @@ describe("error formatting", () => {
     );
   });
 
-  it("formats worker errors with a prelude and worker tag", () => {
+  it("formats worker errors with a prelude, [Error] label, and worker tag", () => {
     vi.spyOn(Math, "random").mockReturnValue(0);
     expect(formatWorkerError("missing token")).toBe(
-      `${ERROR_PRELUDE_LINES[0]}\nworker: missing token`,
+      `${ERROR_PRELUDE_LINES[0]}\n[Error] worker: missing token`,
     );
   });
 });
diff --git a/tests/integration.test.ts b/tests/integration.test.ts
index f096222..5f0ff7c 100644
--- a/tests/integration.test.ts
+++ b/tests/integration.test.ts
@@ -95,6 +95,42 @@ describe("integration", () => {
     );
   });
 
+  it("suggests a subcommand for a near-miss like `lst`", () => {
+    const cliPath = path.resolve(__dirname, "..", "dist", "cli.js");
+    const res = spawnSync("node", [cliPath, "lst"], {
+      cwd: path.resolve(__dirname, ".."),
+      env: process.env,
+      encoding: "utf8",
+    });
+
+    expect(res.status).toBe(1);
+    expect(res.stderr).toContain(
+      '[Error] Unknown command "lst". Did you mean "list"?',
+    );
+    expect(ERROR_PRELUDE_LINES.some((line) => res.stderr.includes(line))).toBe(
+      true,
+    );
+  });
+
+  it("routes commander parse errors through the unified error format", () => {
+    const cliPath = path.resolve(__dirname, "..", "dist", "cli.js");
+    const res = spawnSync("node", [cliPath, "list", "--bogus"], {
+      cwd: path.resolve(__dirname, ".."),
+      env: process.env,
+      encoding: "utf8",
+    });
+
+    expect(res.status).toBe(1);
+    expect(res.stderr).toContain("[Error]");
+    expect(res.stderr).toMatch(/unknown option/i);
+    // No lowercase `error:` prefix and no usage dump.
+    expect(res.stderr).not.toMatch(/^error:/m);
+    expect(res.stderr).not.toContain("Usage:");
+    expect(ERROR_PRELUDE_LINES.some((line) => res.stderr.includes(line))).toBe(
+      true,
+    );
+  });
+
   it("treats bare positionals as tasks when --at is used", () => {
     const cliPath = path.resolve(__dirname, "..", "dist", "cli.js");
     const res = spawnSync(
diff --git a/tests/list.test.ts b/tests/list.test.ts
index cd26780..08477e5 100644
--- a/tests/list.test.ts
+++ b/tests/list.test.ts
@@ -4,6 +4,7 @@ import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { runList } from "../src/commands/list.js";
 import { createJob } from "../src/state/jobStore.js";
+import { stringWidth } from "../src/util/textWidth.js";
 
 let tmpDir: string;
 
@@ -82,4 +83,121 @@ describe("runList", () => {
 
     expect(output).toContain("Trace the deeply nested failure path… (+1 more)");
   });
+
+  it("aligns columns using display width for wide characters", async () => {
+    await createJob({
+      id: "ct_wide",
+      status: "pending",
+      createdAt: "2026-05-18T12:00:00.000Z",
+      dueAt: "2026-05-18T13:00:00.000Z",
+      delaySeconds: 3600,
+      cwd: tmpDir,
+      claudeBin: "claude",
+      tasks: ["日本語のタスク"],
+      schedulerToken: "token-wide",
+      logFile: path.join(tmpDir, "wide.log"),
+    });
+
+    const output = await runList({
+      verbose: false,
+      json: false,
+      all: false,
+      now: new Date("2026-05-18T12:00:00.000Z"),
+    });
+
+    const lines = output.split("\n");
+    // The "Status" column must start at the same *display* column on the header
+    // and data rows (code-unit offsets differ because CJK glyphs are 2 wide).
+    const headerCol = stringWidth(
+      lines[0].slice(0, lines[0].indexOf("Status")),
+    );
+    const dataCol = stringWidth(lines[1].slice(0, lines[1].indexOf("pending")));
+    expect(dataCol).toBe(headerCol);
+  });
+
+  it("collapses embedded newlines so a task stays on one row", async () => {
+    await createJob({
+      id: "ct_nl",
+      status: "pending",
+      createdAt: "2026-05-18T12:00:00.000Z",
+      dueAt: "2026-05-18T13:00:00.000Z",
+      delaySeconds: 3600,
+      cwd: tmpDir,
+      claudeBin: "claude",
+      tasks: ["line one\nline two"],
+      schedulerToken: "token-nl",
+      logFile: path.join(tmpDir, "nl.log"),
+    });
+
+    const output = await runList({
+      verbose: false,
+      json: false,
+      all: false,
+      now: new Date("2026-05-18T12:00:00.000Z"),
+    });
+
+    expect(output).toContain("line one line two");
+    // Exactly one data row (plus the header).
+    expect(output.split("\n")).toHaveLength(2);
+  });
+
+  it("verbose view includes a Due in countdown", async () => {
+    await createJob({
+      id: "ct_v",
+      status: "pending",
+      createdAt: "2026-05-18T12:00:00.000Z",
+      dueAt: "2026-05-18T13:00:00.000Z",
+      delaySeconds: 3600,
+      cwd: tmpDir,
+      claudeBin: "claude",
+      tasks: ["do the thing"],
+      schedulerToken: "token-v",
+      logFile: path.join(tmpDir, "v.log"),
+    });
+
+    const output = await runList({
+      verbose: true,
+      json: false,
+      all: false,
+      now: new Date("2026-05-18T12:00:00.000Z"),
+    });
+
+    expect(output).toContain("Due in: 1h");
+  });
+
+  it("keeps a first-task preview even with an enormous task count", async () => {
+    const tasks = Array.from({ length: 1000 }, (_, i) => `task ${i}`);
+    await createJob({
+      id: "ct_many",
+      status: "pending",
+      createdAt: "2026-05-18T12:00:00.000Z",
+      dueAt: "2026-05-18T13:00:00.000Z",
+      delaySeconds: 3600,
+      cwd: tmpDir,
+      claudeBin: "claude",
+      tasks,
+      schedulerToken: "token-many",
+      logFile: path.join(tmpDir, "many.log"),
+    });
+
+    const output = await runList({
+      verbose: false,
+      json: false,
+      all: false,
+      now: new Date("2026-05-18T12:00:00.000Z"),
+    });
+
+    expect(output).toContain("task 0");
+    expect(output).toContain("(+999 more)");
+  });
+
+  it("labels the empty state consistently", async () => {
+    const output = await runList({
+      verbose: false,
+      json: false,
+      all: false,
+      now: new Date("2026-05-18T12:00:00.000Z"),
+    });
+    expect(output).toBe("[Info] No pending jobs.");
+  });
 });
diff --git a/tests/reconcile.test.ts b/tests/reconcile.test.ts
index 3e7c110..27e59bb 100644
--- a/tests/reconcile.test.ts
+++ b/tests/reconcile.test.ts
@@ -144,7 +144,7 @@ describe("reconcileOrphans", () => {
     );
 
     const out = await runList({ verbose: false, json: false, all: false });
-    expect(out).toBe("No pending jobs.");
+    expect(out).toBe("[Info] No pending jobs.");
     expect((await getJob("ct_lorphan"))?.status).toBe("dispatched");
   });
 });
diff --git a/tests/schedule.test.ts b/tests/schedule.test.ts
index a93b2ba..0e1b380 100644
--- a/tests/schedule.test.ts
+++ b/tests/schedule.test.ts
@@ -35,12 +35,57 @@ describe("runSchedule", () => {
     });
     expect(res.dryRun).toBe(true);
     expect(res.output).toMatch(
-      /\[Dry run\] Would schedule 1 task to run in 45 minutes/,
+      /\[Dry-run\] Would schedule 1 task to run in 45 minutes/,
     );
+    expect(res.output).toContain("Commands:");
     expect(res.output).toMatch(/claude --bg "task one"/);
     expect(await listJobs()).toEqual([]);
   });
 
+  it("dry-run JSON includes the command preview", async () => {
+    const res = await runSchedule({
+      delay: "45m",
+      positional: ["task one"],
+      taskFlags: [],
+      dryRun: true,
+      claudeBin: "claude",
+      cwd: tmpDir,
+      json: true,
+    });
+    const parsed = JSON.parse(res.output);
+    expect(parsed.commands).toEqual(['claude --bg "task one"']);
+  });
+
+  it("says 'to run now' for an imminent --at instead of '0 seconds'", async () => {
+    // 400ms in the future rounds to a 0-second delay.
+    const now = new Date(2026, 4, 18, 17, 30, 0, 600);
+    const res = await runSchedule({
+      at: "2026-05-18 17:30:01",
+      positional: ["task"],
+      taskFlags: [],
+      dryRun: true,
+      claudeBin: "claude",
+      cwd: tmpDir,
+      json: false,
+      now,
+    });
+    expect(res.output).toContain("to run now.");
+    expect(res.output).not.toContain("0 seconds");
+  });
+
+  it("groups large second-counts with separators", async () => {
+    const res = await runSchedule({
+      delay: "1d",
+      positional: ["task"],
+      taskFlags: [],
+      dryRun: true,
+      claudeBin: "claude",
+      cwd: tmpDir,
+      json: false,
+    });
+    expect(res.output).toContain("(86,400 seconds)");
+  });
+
   it('creates a pending job for "2h" with three tasks', async () => {
     const res = await runSchedule({
       delay: "2h",