schub 0.1.0 → 0.1.2

package/src/components/StatusView.tsx

@@ -1,7 +1,9 @@
+import { dirname, normalize, sep } from "node:path";
 import { Box, Text, useInput } from "ink";
 import React from "react";
-import { type ChangeInfo, listChanges } from "../changes";
+import { type ChangeInfo, listChanges, updateChangeStatus } from "../changes";
 import { findSchubRoot, loadTaskDependencies, type TaskInfo, trimTaskTitle } from "../features/tasks";
+import { openInVsCode } from "../ide";
 
 type StatusSortable = {
   id: string;
@@ -9,6 +11,22 @@ type StatusSortable = {
   status: string;
 };
 
+type StatusViewProps = {
+  refreshIntervalMs?: number;
+  onCopyId: (id: string) => void;
+};
+
+const DEFAULT_REFRESH_INTERVAL_MS = 1000;
+const ACTIVE_TASK_STATUSES = ["blocked", "wip", "ready", "backlog"] as const;
+const CHANGE_TASK_STATUSES = [...ACTIVE_TASK_STATUSES, "done"] as const;
+
+type ChangeTaskCount = {
+  completed: number;
+  total: number;
+};
+
+const AUTO_MARK_STATUSES = new Set(["accepted", "wip"]);
+
 const compareText = (left: string, right: string): number =>
   left.localeCompare(right, undefined, { sensitivity: "base" });
 
@@ -26,82 +44,192 @@ const sortByStatusThenTitle = (left: StatusSortable, right: StatusSortable): num
   return compareText(left.id, right.id);
 };
 
-export default function StatusView() {
-  const schubDir = React.useMemo(() => findSchubRoot(), []);
+const isTaskItem = (item: ChangeInfo | TaskInfo): item is TaskInfo => {
+  const parts = normalize(item.path).split(sep);
+  return parts.includes("tasks");
+};
 
-  const { pendingReview, pendingImplementation, drafts, blocked, wip, ready, backlog } = React.useMemo(() => {
-    if (!schubDir) {
-      return {
-        pendingReview: [],
-        pendingImplementation: [],
-        drafts: [],
-        blocked: [],
-        wip: [],
-        ready: [],
-        backlog: [],
-      };
-    }
-
-    const allTasks = loadTaskDependencies(schubDir, ["blocked", "wip", "ready", "backlog"]);
-
-    const blockedTasks: TaskInfo[] = [];
-    const wipTasks: TaskInfo[] = [];
-    const readyTasks: TaskInfo[] = [];
-    const backlogTasks: TaskInfo[] = [];
-
-    const activeChangeIds = new Set<string>();
-
-    for (const task of allTasks) {
-      const s = task.status.toLowerCase();
-      if (s === "blocked") blockedTasks.push(task);
-      else if (s === "wip") wipTasks.push(task);
-      else if (s === "ready") readyTasks.push(task);
-      else if (s === "backlog") backlogTasks.push(task);
-
-      if (task.changeId) {
-        activeChangeIds.add(task.changeId);
-      }
-    }
-
-    const allChanges = listChanges(schubDir);
-    const pendingReviewChanges: ChangeInfo[] = [];
-    const pendingImplementationChanges: ChangeInfo[] = [];
-    const draftChanges: ChangeInfo[] = [];
-
-    for (const change of allChanges) {
-      const normalized = change.status.toLowerCase();
-      if (normalized.includes("review")) {
-        pendingReviewChanges.push(change);
-      } else if (
-        activeChangeIds.has(change.id) ||
-        normalized.includes("implementing") ||
-        normalized.includes("accepted")
-      ) {
-        pendingImplementationChanges.push(change);
-      } else if (normalized.includes("draft")) {
-        draftChanges.push(change);
-      }
+const formatChangeId = (value: string) => {
+  const match = value.match(/^([Cc]\d{3})_/);
+  return match ? match[1].toUpperCase() : value;
+};
+
+const canAutoMarkChange = (status: string) => AUTO_MARK_STATUSES.has(status.trim().toLowerCase());
+
+const autoMarkChangesDone = (schubDir: string) => {
+  const allTasks = loadTaskDependencies(schubDir, CHANGE_TASK_STATUSES);
+  const changeTaskCounts = new Map<string, ChangeTaskCount>();
+
+  for (const task of allTasks) {
+    if (!task.changeId) {
+      continue;
+    }
+
+    const current = changeTaskCounts.get(task.changeId) ?? { completed: 0, total: 0 };
+    const completed = current.completed + (task.status === "done" ? 1 : 0);
+    changeTaskCounts.set(task.changeId, { completed, total: current.total + 1 });
+  }
+
+  if (changeTaskCounts.size === 0) {
+    return;
+  }
+
+  for (const change of listChanges(schubDir)) {
+    const counts = changeTaskCounts.get(change.id);
+    if (!counts || counts.total === 0 || counts.completed !== counts.total) {
+      continue;
+    }
+
+    if (canAutoMarkChange(change.status)) {
+      updateChangeStatus(schubDir, change.id, "Done");
     }
+  }
+};
 
+const buildStatusData = (schubDir: string | null) => {
+  if (!schubDir) {
     return {
-      pendingReview: pendingReviewChanges.sort(sortByStatusThenTitle),
-      pendingImplementation: pendingImplementationChanges.sort(sortByStatusThenTitle),
-      drafts: draftChanges.sort(sortByStatusThenTitle),
-      blocked: blockedTasks.sort(sortByStatusThenTitle),
-      wip: wipTasks.sort(sortByStatusThenTitle),
-      ready: readyTasks.sort(sortByStatusThenTitle),
-      backlog: backlogTasks.sort(sortByStatusThenTitle),
+      pendingReview: [],
+      pendingImplementation: [],
+      pendingImplementationNoTasks: [],
+      drafts: [],
+      blocked: [],
+      wip: [],
+      ready: [],
+      backlog: [],
+      pendingImplementationCounts: new Map<string, string>(),
     };
-  }, [schubDir]);
+  }
 
-  const allItems = React.useMemo(
-    () => [...pendingReview, ...pendingImplementation, ...drafts, ...blocked, ...wip, ...ready, ...backlog],
-    [pendingReview, pendingImplementation, drafts, blocked, wip, ready, backlog],
-  );
+  const allTasks = loadTaskDependencies(schubDir, CHANGE_TASK_STATUSES);
+
+  const blockedTasks: TaskInfo[] = [];
+  const wipTasks: TaskInfo[] = [];
+  const readyTasks: TaskInfo[] = [];
+  const backlogTasks: TaskInfo[] = [];
+
+  const activeChangeIds = new Set<string>();
+  const changeTaskCounts = new Map<string, ChangeTaskCount>();
+
+  for (const task of allTasks) {
+    if (task.status === "blocked") blockedTasks.push(task);
+    else if (task.status === "wip") wipTasks.push(task);
+    else if (task.status === "ready") readyTasks.push(task);
+    else if (task.status === "backlog") backlogTasks.push(task);
+
+    if (task.changeId && task.status !== "done") {
+      activeChangeIds.add(task.changeId);
+    }
+
+    if (task.changeId) {
+      const current = changeTaskCounts.get(task.changeId) ?? { completed: 0, total: 0 };
+      const completed = current.completed + (task.status === "done" ? 1 : 0);
+      changeTaskCounts.set(task.changeId, { completed, total: current.total + 1 });
+    }
+  }
+
+  const allChanges = listChanges(schubDir);
+  const pendingReviewChanges: ChangeInfo[] = [];
+  const pendingImplementationChanges: ChangeInfo[] = [];
+  const draftChanges: ChangeInfo[] = [];
+
+  for (const change of allChanges) {
+    const normalized = change.status.toLowerCase();
+    if (normalized.includes("review")) {
+      pendingReviewChanges.push(change);
+      continue;
+    }
+
+    const counts = changeTaskCounts.get(change.id);
+    const allTasksCompleted = Boolean(counts && counts.total > 0 && counts.completed === counts.total);
+
+    if (activeChangeIds.has(change.id)) {
+      pendingImplementationChanges.push(change);
+      continue;
+    }
+
+    if ((normalized.includes("implementing") || normalized.includes("accepted")) && !allTasksCompleted) {
+      pendingImplementationChanges.push(change);
+      continue;
+    }
+
+    if (normalized.includes("draft")) {
+      draftChanges.push(change);
+    }
+  }
+
+  const pendingImplementationWithTasks: ChangeInfo[] = [];
+  const pendingImplementationNoTasks: ChangeInfo[] = [];
+  const pendingImplementationCounts = new Map<string, string>();
+
+  for (const change of pendingImplementationChanges.sort(sortByStatusThenTitle)) {
+    const counts = changeTaskCounts.get(change.id);
+    if (counts && counts.total > 0) {
+      pendingImplementationWithTasks.push(change);
+      pendingImplementationCounts.set(change.id, `${counts.completed}/${counts.total}`);
+    } else {
+      pendingImplementationNoTasks.push(change);
+    }
+  }
+
+  return {
+    pendingReview: pendingReviewChanges.sort(sortByStatusThenTitle),
+    pendingImplementation: pendingImplementationWithTasks,
+    pendingImplementationNoTasks,
+    drafts: draftChanges.sort(sortByStatusThenTitle),
+    blocked: blockedTasks.sort(sortByStatusThenTitle),
+    wip: wipTasks.sort(sortByStatusThenTitle),
+    ready: readyTasks.sort(sortByStatusThenTitle),
+    backlog: backlogTasks.sort(sortByStatusThenTitle),
+    pendingImplementationCounts,
+  };
+};
+
+export default function StatusView({ refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, onCopyId }: StatusViewProps) {
+  const schubDir = findSchubRoot();
+  const [, setRefreshTick] = React.useState(0);
+  const {
+    pendingReview,
+    pendingImplementation,
+    pendingImplementationNoTasks,
+    drafts,
+    blocked,
+    wip,
+    ready,
+    backlog,
+    pendingImplementationCounts,
+  } = buildStatusData(schubDir);
+  const repoRoot = schubDir ? dirname(schubDir) : "";
+
+  const allItems = [
+    ...pendingReview,
+    ...pendingImplementation,
+    ...pendingImplementationNoTasks,
+    ...drafts,
+    ...blocked,
+    ...wip,
+    ...ready,
+    ...backlog,
+  ];
 
   const [selection, setSelection] = React.useState(0);
   const totalItems = allItems.length;
 
+  React.useEffect(() => {
+    if (!schubDir) {
+      return;
+    }
+
+    const interval = setInterval(() => {
+      autoMarkChangesDone(schubDir);
+      setRefreshTick((current) => current + 1);
+    }, refreshIntervalMs);
+
+    return () => {
+      clearInterval(interval);
+    };
+  }, [refreshIntervalMs, schubDir]);
+
   React.useEffect(() => {
     if (totalItems === 0) {
       setSelection(0);
@@ -110,7 +238,7 @@ export default function StatusView() {
     setSelection((current) => Math.min(current, totalItems - 1));
   }, [totalItems]);
 
-  useInput((_input, key) => {
+  useInput((input, key) => {
     if (totalItems === 0) {
       return;
     }
@@ -122,6 +250,16 @@ export default function StatusView() {
     if (key.upArrow) {
       setSelection((current) => Math.max(current - 1, 0));
     }
+
+    if (input === "o") {
+      const selectedItem = allItems[selection];
+      openInVsCode(repoRoot, selectedItem.path);
+    }
+
+    if (input === "c") {
+      const selectedItem = allItems[selection];
+      onCopyId(selectedItem.id);
+    }
   });
 
   if (!schubDir) {
@@ -141,19 +279,27 @@ export default function StatusView() {
     );
   }
 
-  const renderRow = (item: ChangeInfo | TaskInfo, index: number) => {
+  const renderRow = (item: ChangeInfo | TaskInfo, index: number, detail?: string) => {
     const selected = index === selection;
-    const isTask = "path" in item && item.path.includes("tasks/");
-    const title = isTask ? trimTaskTitle(item.title) : "";
+    const task = isTaskItem(item) ? item : null;
+    const title = task ? trimTaskTitle(task.title) : "";
+    const checklistIndicator =
+      task && task.status === "wip" && typeof task.checklistTotal === "number"
+        ? ` (${task.checklistRemaining ?? 0}/${task.checklistTotal})`
+        : "";
+    const changeTitle = item.title;
+    const changeDetail = detail ? ` ${detail}` : "";
+    const displayTitle = task ? `${title}${checklistIndicator}` : `${changeTitle}${changeDetail}`.trim();
+    const displayId = task ? item.id : formatChangeId(item.id);
 
     return (
       <Box key={item.id} marginLeft={1}>
         <Text color={selected ? "blue" : "gray"}>{selected ? "›" : " "}</Text>
         <Box marginLeft={1}>
           <Text color="white" bold={selected}>
-            {item.id}
+            {displayId}
           </Text>
-          {title ? <Text color="gray"> {title}</Text> : null}
+          {displayTitle ? <Text color="gray"> {displayTitle}</Text> : null}
         </Box>
       </Box>
     );
@@ -161,11 +307,11 @@ export default function StatusView() {
 
   let currentIndex = 0;
 
-  const renderSection = (title: string, items: (ChangeInfo | TaskInfo)[]) => {
+  const renderSection = (title: string, items: (ChangeInfo | TaskInfo)[], detailById?: Map<string, string>) => {
     if (items.length === 0) return null;
 
     const sectionStartIndex = currentIndex;
-    const sectionItems = items.map((item, i) => renderRow(item, sectionStartIndex + i));
+    const sectionItems = items.map((item, i) => renderRow(item, sectionStartIndex + i, detailById?.get(item.id)));
     currentIndex += items.length;
 
     return (
@@ -182,23 +328,27 @@ export default function StatusView() {
     <Box flexDirection="column">
       <Box flexDirection="column" marginBottom={1}>
         <Box marginBottom={1}>
-          <Text bold color="white" underline>
+          <Text bold color="white">
             Change Proposals
           </Text>
         </Box>
         {renderSection("Pending Review", pendingReview)}
-        {renderSection("Pending Implementation", pendingImplementation)}
+        {renderSection("Pending Implementation", pendingImplementation, pendingImplementationCounts)}
+        {renderSection("No Tasks Defined", pendingImplementationNoTasks)}
         {renderSection("Drafts", drafts)}
-        {pendingReview.length === 0 && pendingImplementation.length === 0 && drafts.length === 0 && (
-          <Box marginLeft={1}>
-            <Text color="gray">No active proposals.</Text>
-          </Box>
-        )}
+        {pendingReview.length === 0 &&
+          pendingImplementation.length === 0 &&
+          pendingImplementationNoTasks.length === 0 &&
+          drafts.length === 0 && (
+            <Box marginLeft={1}>
+              <Text color="gray">No active proposals.</Text>
+            </Box>
+          )}
       </Box>
 
       <Box flexDirection="column">
         <Box marginBottom={1}>
-          <Text bold color="white" underline>
+          <Text bold color="white">
             Tasks
           </Text>
         </Box>

package/src/features/tasks/constants.ts

@@ -8,6 +8,8 @@ export type TaskInfo = {
   status: TaskStatus;
   path: string;
   changeId?: string;
+  checklistRemaining?: number;
+  checklistTotal?: number;
 };
 
 export type TaskDependency = TaskInfo & {

package/src/features/tasks/create.ts

@@ -1,14 +1,22 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-
-const TASK_TEMPLATE_PATH = fileURLToPath(new URL("../../../templates/create-tasks/task-template.md", import.meta.url));
-
-const readTaskTemplate = () => {
+import { resolveTemplatePath } from "../../templates";
+
+const BUNDLED_TASK_TEMPLATE_PATH = fileURLToPath(
+  new URL("../../../templates/create-tasks/task-template.md", import.meta.url),
+);
+
+const readTaskTemplate = (schubDir: string) => {
+  const templatePath = resolveTemplatePath(
+    schubDir,
+    join("create-tasks", "task-template.md"),
+    BUNDLED_TASK_TEMPLATE_PATH,
+  );
   try {
-    return readFileSync(TASK_TEMPLATE_PATH, "utf8");
+    return readFileSync(templatePath, "utf8");
   } catch {
-    throw new Error(`[ERROR] Template not found: ${TASK_TEMPLATE_PATH}`);
+    throw new Error(`[ERROR] Template not found: ${templatePath}`);
   }
 };
 
@@ -89,7 +97,7 @@ export const createTask = (
   let nextNumber = existingNumbers.size > 0 ? Math.max(...existingNumbers) + 1 : 1;
   const statusDir = join(tasksRoot, status);
   mkdirSync(statusDir, { recursive: true });
-  const template = readTaskTemplate();
+  const template = readTaskTemplate(schubDir);
 
   const createdPaths: string[] = [];
 

package/src/features/tasks/filesystem.test.ts

@@ -0,0 +1,78 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { listTasks, loadTaskDependencies } from "./filesystem";
+
+const setupChecklistRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-checklist-"));
+  const schubDir = join(base, ".schub");
+  const tasksRoot = join(schubDir, "tasks", "backlog");
+  mkdirSync(tasksRoot, { recursive: true });
+
+  const tasks = [
+    {
+      id: "T001",
+      slug: "unchecked-only",
+      body: `# Task: T001 Unchecked Only\n\n## Steps\n- [ ] First item\n- [ ] Second item\n`,
+    },
+    {
+      id: "T002",
+      slug: "checked-only",
+      body: `# Task: T002 Checked Only\n\n## Steps\n- [x] Finished item\n`,
+    },
+    {
+      id: "T003",
+      slug: "mixed-checklist",
+      body: `# Task: T003 Mixed Checklist\n\n## Steps\n- [ ] Remaining item\n- [x] Done item\n\n## Acceptance\n- [ ] Ignore this\n`,
+    },
+    {
+      id: "T004",
+      slug: "missing-checklist",
+      body: `# Task: T004 Missing Checklist\n\n## Steps\n- Do the thing\n- Another item\n\n## Acceptance\n- [ ] Ignore this too\n`,
+    },
+  ];
+
+  for (const task of tasks) {
+    const filePath = join(tasksRoot, `${task.id}_${task.slug}.md`);
+    writeFileSync(filePath, task.body, "utf8");
+  }
+
+  return schubDir;
+};
+
+const getTaskById = <T extends { id: string }>(tasks: T[], id: string) => {
+  return tasks.find((task) => task.id === id);
+};
+
+test("listTasks includes Steps-only checklist counts", () => {
+  const schubDir = setupChecklistRepo();
+  const tasks = listTasks(schubDir);
+
+  const unchecked = getTaskById(tasks, "T001");
+  const checked = getTaskById(tasks, "T002");
+  const mixed = getTaskById(tasks, "T003");
+  const missing = getTaskById(tasks, "T004");
+
+  expect(unchecked).toMatchObject({ checklistTotal: 2, checklistRemaining: 2 });
+  expect(checked).toMatchObject({ checklistTotal: 1, checklistRemaining: 0 });
+  expect(mixed).toMatchObject({ checklistTotal: 2, checklistRemaining: 1 });
+  expect(missing?.checklistTotal).toBeUndefined();
+  expect(missing?.checklistRemaining).toBeUndefined();
+});
+
+test("loadTaskDependencies includes Steps-only checklist counts", () => {
+  const schubDir = setupChecklistRepo();
+  const tasks = loadTaskDependencies(schubDir);
+
+  const unchecked = getTaskById(tasks, "T001");
+  const checked = getTaskById(tasks, "T002");
+  const mixed = getTaskById(tasks, "T003");
+  const missing = getTaskById(tasks, "T004");
+
+  expect(unchecked).toMatchObject({ checklistTotal: 2, checklistRemaining: 2 });
+  expect(checked).toMatchObject({ checklistTotal: 1, checklistRemaining: 0 });
+  expect(mixed).toMatchObject({ checklistTotal: 2, checklistRemaining: 1 });
+  expect(missing?.checklistTotal).toBeUndefined();
+  expect(missing?.checklistRemaining).toBeUndefined();
+});

package/src/features/tasks/filesystem.ts

@@ -49,6 +49,51 @@ type ParsedTaskFile = {
   title: string;
   dependsOn: string[];
   changeId?: string;
+  checklistRemaining?: number;
+  checklistTotal?: number;
+};
+
+const parseChecklistCounts = (content: string) => {
+  const lines = content.split(/\r?\n/);
+  let inSteps = false;
+  let checklistTotal = 0;
+  let checklistRemaining = 0;
+
+  for (const line of lines) {
+    const headingMatch = line.match(/^##\s+(.*)$/);
+    if (headingMatch) {
+      const heading = headingMatch[1].trim().toLowerCase();
+      if (heading === "steps") {
+        inSteps = true;
+      } else if (inSteps) {
+        break;
+      }
+      continue;
+    }
+
+    if (!inSteps) {
+      continue;
+    }
+
+    const checklistMatch = line.match(/^\s*-\s+\[( |x|X)\]/);
+    if (!checklistMatch) {
+      continue;
+    }
+
+    checklistTotal += 1;
+    if (checklistMatch[1].toLowerCase() !== "x") {
+      checklistRemaining += 1;
+    }
+  }
+
+  if (checklistTotal === 0) {
+    return null;
+  }
+
+  return {
+    checklistRemaining,
+    checklistTotal,
+  };
 };
 
 const parseTaskFile = (filePath: string, fallback: { id: string; title: string }): ParsedTaskFile => {
@@ -59,10 +104,6 @@ const parseTaskFile = (filePath: string, fallback: { id: string; title: string }
     return { ...fallback, dependsOn: [] };
   }
 
-  const headerMatch = content.match(/^#\s*Task:\s*(\S+)\s+(.+)$/m);
-  const id = headerMatch?.[1] ?? fallback.id;
-  const title = headerMatch?.[2]?.trim() ?? fallback.title;
-
   const changeIdMatch = content.match(/^\*\*Change ID\*\*:\s*\[?`?([^\]`]+)`?]?/m);
   const changeId = changeIdMatch?.[1]?.trim();
 
@@ -78,7 +119,15 @@ const parseTaskFile = (filePath: string, fallback: { id: string; title: string }
     }
   }
 
-  return { id, title, dependsOn, changeId };
+  const checklistCounts = parseChecklistCounts(content);
+
+  return {
+    id: fallback.id,
+    title: fallback.title,
+    dependsOn,
+    changeId,
+    ...(checklistCounts ?? {}),
+  };
 };
 
 export const listTasks = (schubDir: string, statuses: readonly TaskStatus[] = TASK_STATUSES): TaskInfo[] => {
@@ -113,11 +162,14 @@ export const listTasks = (schubDir: string, statuses: readonly TaskStatus[] = TA
       }
 
       const filePath = join(statusDir, entry.name);
+      const parsedFile = parseTaskFile(filePath, parsed);
       tasks.push({
         id: parsed.id,
         title: parsed.title,
         status,
         path: relative(repoRoot, filePath),
+        checklistRemaining: parsedFile.checklistRemaining,
+        checklistTotal: parsedFile.checklistTotal,
       });
     }
   }
@@ -164,12 +216,14 @@ export const loadTaskDependencies = (
       const dependsOn = parsedFile.dependsOn.sort(compareTaskIds);
 
       tasks.push({
-        id: parsedFile.id,
-        title: parsedFile.title,
+        id: parsed.id,
+        title: parsed.title,
         status,
         path: relative(repoRoot, filePath),
         dependsOn,
         changeId: parsedFile.changeId,
+        checklistRemaining: parsedFile.checklistRemaining,
+        checklistTotal: parsedFile.checklistTotal,
       });
     }
   }

package/src/ide.ts

@@ -0,0 +1,7 @@
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+
+export const openInVsCode = (repoRoot: string, relativePath: string) => {
+  const targetPath = resolve(repoRoot, relativePath);
+  spawn("code", ["-g", targetPath], { stdio: "ignore" }).unref();
+};

package/src/index.test.ts

@@ -0,0 +1,23 @@
+import { expect, test } from "bun:test";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "bun";
+
+test("schub help lists tasks list", () => {
+  const testDir = dirname(fileURLToPath(import.meta.url));
+  const cliDir = resolve(testDir, "..");
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "--help"],
+    cwd: cliDir,
+  });
+
+  expect(result.exitCode).toBe(0);
+  const stdout = new TextDecoder().decode(result.stdout ?? new Uint8Array());
+  expect(stdout).toContain("changes create");
+  expect(stdout).toContain("eject");
+  expect(stdout).toContain("init");
+  expect(stdout).toContain("tasks list");
+  expect(stdout).toContain("review complete");
+  expect(stdout).not.toContain("lint");
+  expect(stdout).not.toContain("format");
+});