schub 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schub",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "bin": {
     "schub": "./src/index.ts"
@@ -8,10 +8,12 @@
   "files": [
     "dist",
     "src",
+    "skills",
     "templates"
   ],
   "scripts": {
     "schub": "bun ./src/index.ts",
+    "prepublishOnly": "npm run build",
     "build": "bun build ./src/index.ts --outdir dist --target node",
     "lint": "bunx @biomejs/biome lint .",
     "format": "bunx @biomejs/biome format --write .",

package/skills/create-proposal/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: create-proposal
+description: "Create or update proposals and review requirements with the user. Use this when asked to write a proposal, introduce changes that add features, large refactors, introduce breaking API or schema changes, modify architecture or design patterns, update security patterns, or after creating a plan, to save a plan as proposal. Do not create proposals for bug fixes that restore intended behavior, typos or formatting/comment-only changes, non-breaking dependency updates, configuration-only changes, or tests that validate existing behavior."
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+## Workflow
+
+1. Derive a concise, verb-led `change-id` suffix from the request (kebab-case: `add-`, `update-`, `remove-`, `refactor-`, `fix-`) and prefix it with `C` + the next 3-digit sequence + `_` (e.g., `C001_add-user-auth`).
+2. Run `npx schub changes create --change-id "<change-id>" --title "<title>" --input "<user prompt verbatim>"` to scaffold the proposal template.
+   - Supported flags: `--change-id`, `--title`, `--input`, `--overwrite`.
+3. Update the generated proposal with concrete, testable statements.
+4. Identify the touch points throughout the project and track them in the proposal.
+5. Track missing information with [MISSING INFORMATION] tags in the proposal.
+6. (OPTIONAL) If the change affects a public surface, e.g. an api / sdk / cli. Run `npx schub cookbook create --change-id "<change-id>"` to scaffold `cookbook.md`.
+7. (OPTIONAL) If implementing the change requires knowledge of an api / db schema etc. encode this in`contracts.md` or `schemas.md` files
+8. (OPTIONAL) For complex tasks requiring deep understanding of the system, track relevant additional information in `research.md`
+9. (OPTIONAL) For decisions with lasting architectural impact or important tradeoffs, run `npx schub adr create --change-id "<change-id>" --title "<title>"`.
+10. Proceed with the review-proposal skill (even without user request).
+
+## Output Locations
+
+- Proposal: `.schub/changes/<change-id>/proposal.md`
+- (OPTIONAL) Cookbook: `.schub/changes/<change-id>/cookbook.md`
+- (OPTIONAL) Schemas: `.schub/changes/<change-id>/schemas.md`
+- (OPTIONAL) Contracts: `.schub/changes/<change-id>/contracts.md`
+- (OPTIONAL) Research: `.schub/changes/<change-id>/research.md`
+- (OPTIONAL) ADR: `.schub/changes/<change-id>/adr.md`

package/skills/create-tasks/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: create-tasks
+description: "Break an accepted proposal into actionable task files under `.schub/tasks/` using the task template. Use when asked to create tasks for a change-id."
+---
+
+## User Input (should contain change-id or shorthand `C###`)
+
+```text
+$ARGUMENTS
+```
+
+## Workflow
+
+1. If the user provides shorthand `C###`, resolve it to the matching `C###_<suffix>` change folder (error if ambiguous). Confirm `.schub/changes/<change-id>/proposal.md` exists and that it is marked accepted. If it is missing, ask the user to run the create-proposal skill first. If it is still a draft, ask the user to review it first.
+2. Read the proposal and other files in the <change-id> folder.
+3. Derive tasks, each task should be:
+   - Small enough to implement in one sitting.
+   - Independently testable.
+   - Explicit about file paths and affected components.
+4. Assign a unique task id using `T###` (ex: `T001`) and avoid collisions with existing tasks.
+5. Run `npx schub tasks create --change-id "<change-id>" --title "<task title>"` to scaffold tasks.
+   - Repeat `--title` for multiple tasks.
+   - Optional flags: `--status "<status>"` (default: `backlog`), `--overwrite`.
+6. Fill the template fields with concrete details
+   - Priority (P1/P2/P3)
+   - Parallelizable (yes/no)
+   - Goal, scope, steps, acceptance, and evidence
+7. When defining the acceptance, include relevant tests, e2e commands and documentation updates.
+8. Resolve blockers by check all existing tasks that are not done. If another task is a blocker, add it to **Depends on**.
+9. Stop after the task files are created. Do not implement code or modify the plan or supporting artifacts.
+
+## Output Locations
+
+- `.schub/tasks/backlog/<task-id>_<task-name>.md`
+
+## Task Notes
+
+- Use the plan's acceptance alignment to define acceptance criteria.
+- Split tasks that span multiple systems or large scopes.
+- Record assumptions in the task body if key details are missing.

package/skills/implement-task/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: implement-task
+description: "Implement a single task end-to-end: locate the task file by id, move it across status folders (`ready`, `wip`, `blocked`, `done`). Use when asked to implement or complete a task."
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+## Workflow
+
+1. **Identify the task**
+   - Accept: task id, full filename, or `next` / `continue`.
+   - If unclear or missing, ask for **one**: task id (kebab-case), exact filename, or `next`.
+
+2. **Find the task file**
+   - If `next` / `continue`: sort `.schub/tasks/ready/`, pick the first file.
+   - Otherwise search `.schub/tasks/{ready,backlog,wip,done,blocked}/` for `<task-id>_*.md`.
+   - If multiple matches, ask the user to choose.
+   - If none found, ask the user to confirm the task id.
+
+3. **Move the task before work**
+   - If starting work: move to `.schub/tasks/wip/` (create folder if needed).
+   - If blocked: move to `.schub/tasks/blocked/` and record the blocker in the task file.
+   - If complete: move to `.schub/tasks/done/` after confirming all checklists are checked.
+   - Keep the task in **exactly one** status folder.
+
+4. **TDD loop**
+   - **Write tests first (Red)**
+     - Add/extend tests based on `## Acceptance` (and key `## Steps`).
+     - Run tests and confirm they fail for the right reason.
+   - **Implement the smallest change (Green)**
+     - Write minimal code to make the failing test pass.
+     - Re-run tests until green.
+   - **Refactor (Refactor)**
+     - Clean up code and tests (names, structure, duplication) without changing behavior.
+     - Re-run tests to confirm still green.
+   - Repeat until all acceptance criteria are covered by tests and passing.
+
+6. **Update task checklists as you go**
+   - Check off `## Steps` only when:
+     - A test exists that covers it, and
+     - Tests pass, and
+     - Any required refactor is done.
+   - Check off `## Acceptance` only when:
+     - There’s test coverage for it, and
+     - The full test suite is green.
+
+7. **Evidence**
+   - Update the task file `## Evidence` section to reference generated artifacts.
+   - If tests/commands can’t be run, record why in `## Evidence`.
+
+8. **Finish**
+   - Confirm everything in `## Steps` and `## Acceptance` is checked.
+   - If the task is not completed due to errors, move the task file to `.schub/tasks/blocked/`.
+   - If the task is completed, move the task file to `.schub/tasks/done/`.
+   - Report completed files and artifacts.
+
+## Validation
+
+To be considered "done", a task should provide Validation Artifacts. Validation Artifacts are **verifiable outputs** produced while doing the task.
+e.g. by running `some_command &> some-logs.txt`
+
+Agents should dump and review artifacts, including:
+
+- Test, Build and Run outputs
+- Walkthroughs
+- Screenshots or screen recordings (UI / E2E)
+- `curl` responses
+- Any files needed to prove the task is implemented correctly
+
+Artifacts **must** be:
+
+- Concrete
+- Inspectable
+- Reproducible
+- Referenced as evidence in the task
+
+## Output Locations
+
+- Tasks: `.schub/tasks/{ready,backlog,wip,done,blocked}/<task-id>_<task-name>.md`
+- Validation Artifacts: `.schub/artifacts/<task-id>/`

package/skills/review-proposal/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: review-proposal
+description: "Run a review session for a proposal by creating a list of open questions, updating the proposal, adding a Q&A section, and deleting REVIEW_ME.md on completion. Use when asked to review proposals."
+---
+
+## User Input (change-id or shorthand `C###`)
+
+```text
+$ARGUMENTS
+```
+
+## Workflow
+
+0. If the user provides shorthand `C###`, resolve it to the matching `C###_<suffix>` change folder (error if ambiguous). Mark the proposal Status as "In Review"
+1. Review the proposal by checking the [MISSING INFORMATION] tags and the potential issues listed.
+2. If there are issues, or missing information, run `npx schub review create --change-id "<change-id>"` to scaffold `.schub/changes/<change-id>/REVIEW_ME.md`.
+3. Triage each item:
+   - **High-stakes** (scope, risks, dependencies, security, performance): create a bullet point item in the review checklist.
+   - **Minute details** (naming, copy, formatting, low-impact defaults): make a decision update the proposal and mark as an assumption in the proposal.
+4. Once the review checklist is completed, gather unchecked items (`- [ ]`) in order.
+5. Start the review loop (process unchecked items in order), ask each item as a question. If unclear, ask a quick follow-up and do not advance.
+   - Update the review checklist accordingly inline with the answers.
+6. When no unchecked items remain, update the plan with the new information.
+7. When no unchecked items remain, run `npx schub review complete --change-id "<change-id>"` to create `.schub/changes/<change-id>/Q&A.md`.
+   - Ask the LLM to migrate the TODO block into the Q&A sections and remove the TODO block.
+8. Mark the proposal Status as "Accepted".
+
+## Output Locations
+
+- Proposal: `.schub/changes/<change-id>/proposal.md`
+- (OPTIONAL) Review In Progress: `.schub/changes/<change-id>/REVIEW_ME.md`
+- (OPTIONAL) Review Completed: `.schub/changes/<change-id>/Q&A.md`
+
+## Notes
+
+- Avoid expanding scope beyond missing information in the proposal.
+- Focus review on high-stakes issues; place details into assumptions instead of asking.

package/skills/setup-project/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: setup-project
+description: "Set up or refresh project-level reference files in `.schub/`: project-overview.md, project-setup.md, and project-wow.md. Use when initializing a project or when the overview/setup/ways-of-working docs need to be created or updated."
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+## Workflow
+
+1. Run `npx schub project create --project-name "<name>"` to copy templates and insert the project name.
+   - Optional flags: `--project-name`, `--repo-root`, `--overwrite`.
+2. If the files already exist, ask whether to overwrite or update in place.
+3. Explore the repo to gather as much information as possible to complete the templates.
+   - Use existing project sources (README, package manifests, docs, infra configs) to fill in details.
+4. Replace remaining placeholders with concrete project details.
+   - mark unresolved items with `[MISSING INFORMATION]`.
+5. Ensure `project-setup.md` reflects the desired repository layout and current tech stack.
+6. Gather all `[MISSING INFORMATION]` into one `REVIEW_ME.md` file by running `npx schub review create --change-id "project-setup" --title "<project name>" --output "REVIEW_ME.md"`.
+7. Stop after the three files are created or updated.
+
+## Output Locations
+
+- `.schub/project-overview.md`
+- `.schub/project-setup.md`
+- `.schub/project-wow.md`

package/src/App.test.tsx

@@ -0,0 +1,93 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { render } from "ink-testing-library";
+import packageJson from "../package.json";
+import App from "./App";
+import { findSchubRoot } from "./features/tasks";
+
+const schubDir = findSchubRoot(process.env.SCHUB_CWD ?? process.cwd())!;
+const homeDir = homedir();
+const displaySchubDir =
+  schubDir === homeDir ? "~" : schubDir.startsWith(`${homeDir}/`) ? `~${schubDir.slice(homeDir.length)}` : schubDir;
+
+const ansiPattern = new RegExp(`${String.fromCharCode(27)}[[0-9;]*m`, "g");
+const stripAnsi = (value: string) => value.replace(ansiPattern, "");
+
+test("renders tabs with header and footer details", () => {
+  const { lastFrame } = render(<App />);
+  const output = stripAnsi(lastFrame() || "");
+  expect(output).toContain("Status");
+  expect(output).toContain("Plan");
+  expect(output).toContain("switch mode");
+  expect(output).toContain("[o open file]");
+  expect(output).toContain("[c copy]");
+  expect(output).toContain(displaySchubDir);
+  expect(output).toContain(packageJson.version);
+});
+
+test("selected tab shows a blue left indicator", () => {
+  const originalForceColor = process.env.FORCE_COLOR;
+  process.env.FORCE_COLOR = "1";
+
+  try {
+    const { lastFrame } = render(<App />);
+    const output = lastFrame() || "";
+    const statusLine = output.split("\n").find((line) => line.includes("Status")) ?? "";
+    expect(statusLine).toContain("Status");
+    expect(statusLine).not.toContain("│");
+  } finally {
+    if (originalForceColor === undefined) {
+      delete process.env.FORCE_COLOR;
+    } else {
+      process.env.FORCE_COLOR = originalForceColor;
+    }
+  }
+});
+
+test("shows a copy banner after copying an item", async () => {
+  const originalCwd = process.cwd();
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-copy-"));
+  const readyRoot = join(baseDir, ".schub", "tasks", "ready");
+  let copied = "";
+  const recordCopy = (value: string) => {
+    copied = value;
+  };
+
+  mkdirSync(readyRoot, { recursive: true });
+  writeFileSync(join(readyRoot, "T900_copy-task.md"), "# Task: T900 Copy Task\n", "utf8");
+
+  try {
+    process.chdir(baseDir);
+    const rendered = render(<App copyToClipboard={recordCopy} />);
+    rendered.stdin.write("c");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    const output = rendered.lastFrame() ?? "";
+    expect(copied).toBe("T900");
+    expect(output).toContain("Copied to clipboard !");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("renders when no .schub directory is found", () => {
+  const originalCwd = process.cwd();
+  const originalSchubCwd = process.env.SCHUB_CWD;
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-"));
+  process.env.SCHUB_CWD = baseDir;
+
+  try {
+    process.chdir(baseDir);
+    const { lastFrame } = render(<App />);
+    const output = lastFrame() ?? "";
+    expect(output).toContain("No .schub directory found.");
+  } finally {
+    process.chdir(originalCwd);
+    if (originalSchubCwd === undefined) {
+      delete process.env.SCHUB_CWD;
+    } else {
+      process.env.SCHUB_CWD = originalSchubCwd;
+    }
+  }
+});

package/src/App.tsx

@@ -2,6 +2,7 @@ import { homedir } from "node:os";
 import { Box, Text, useInput, useStdout } from "ink";
 import React from "react";
 import packageJson from "../package.json";
+import { copyToClipboard as copyToClipboardDefault } from "./clipboard";
 import PlanView from "./components/PlanView";
 import StatusView from "./components/StatusView";
 import { findSchubRoot } from "./features/tasks";
@@ -18,18 +19,49 @@ const tabs: TabDefinition[] = [
   { id: "plan", label: "Plan" },
 ];
 
-export default function App() {
+type AppProps = {
+  copyToClipboard?: (value: string) => void;
+};
+
+const COPY_BANNER_TEXT = "Copied to clipboard !";
+const COPY_BANNER_TIMEOUT_MS = 1500;
+
+export default function App({ copyToClipboard = copyToClipboardDefault }: AppProps) {
   const [mode, setMode] = React.useState<Mode>("status");
   const { stdout } = useStdout();
   const [dimensions, setDimensions] = React.useState(() => ({
     columns: stdout.columns,
     rows: stdout.rows,
   }));
+  const [copyBanner, setCopyBanner] = React.useState<string | null>(null);
   const versionLabel = `${packageJson.version}`;
   const homeDir = homedir();
-  const schubDir = findSchubRoot(process.env.SCHUB_CWD ?? process.cwd())!;
-  const displaySchubDir =
-    schubDir === homeDir ? "~" : schubDir.startsWith(`${homeDir}/`) ? `~${schubDir.slice(homeDir.length)}` : schubDir;
+  const startDir = process.env.SCHUB_CWD ?? process.cwd();
+  const schubDir = findSchubRoot(startDir);
+  const displaySchubDir = (() => {
+    const targetDir = schubDir ?? startDir;
+    if (targetDir === homeDir) {
+      return "~";
+    }
+    if (targetDir.startsWith(`${homeDir}/`)) {
+      return `~${targetDir.slice(homeDir.length)}`;
+    }
+    return targetDir;
+  })();
+
+  React.useEffect(() => {
+    if (!copyBanner) {
+      return;
+    }
+
+    const timeout = setTimeout(() => {
+      setCopyBanner(null);
+    }, COPY_BANNER_TIMEOUT_MS);
+
+    return () => {
+      clearTimeout(timeout);
+    };
+  }, [copyBanner]);
 
   React.useEffect(() => {
     const handleResize = () => {
@@ -49,6 +81,16 @@ export default function App() {
     }
   });
 
+  const handleCopyId = (value: string) => {
+    copyToClipboard(value);
+    setCopyBanner(COPY_BANNER_TEXT);
+  };
+
+  const shortcuts = [
+    { keyLabel: "o", label: "open file" },
+    { keyLabel: "c", label: "copy" },
+  ];
+
   return (
     <Box backgroundColor="black" flexDirection="column" width={dimensions.columns} height={dimensions.rows}>
       <Box flexDirection="column" paddingX={2} paddingY={1} flexShrink={0}>
@@ -77,21 +119,31 @@ export default function App() {
               );
             })}
           </Box>
+          {copyBanner ? (
+            <Box backgroundColor="green" paddingX={1}>
+              <Text color="black">{copyBanner}</Text>
+            </Box>
+          ) : null}
         </Box>
       </Box>
       <Box flexDirection="column" paddingX={2} paddingY={1} flexGrow={1} flexShrink={1}>
-        {mode === "status" ? <StatusView /> : <PlanView />}
+        {mode === "status" ? <StatusView onCopyId={handleCopyId} /> : <PlanView onCopyId={handleCopyId} />}
       </Box>
       <Box flexDirection="column" paddingX={2} paddingBottom={1} flexShrink={0}>
-        <Box justifyContent="flex-end">
+        <Box justifyContent="space-between">
+          <Box flexDirection="row">
+            {shortcuts.map((shortcut) => (
+              <Box key={shortcut.keyLabel} marginRight={2}>
+                <Text color="gray">[</Text>
+                <Text color="white">{shortcut.keyLabel}</Text>
+                <Text color="gray"> {shortcut.label}]</Text>
+              </Box>
+            ))}
+          </Box>
           <Box marginRight={2}>
             <Text>tab</Text>
             <Text color="gray"> switch mode</Text>
           </Box>
-          <Box>
-            <Text>ctrl+p</Text>
-            <Text color="gray"> commands</Text>
-          </Box>
         </Box>
         <Box justifyContent="space-between" marginTop={1}>
           <Text color="gray">{displaySchubDir}</Text>

package/src/changes.ts

@@ -1,6 +1,8 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative, resolve } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveSchubRoot } from "./schub-root";
+import { resolveTemplatePath } from "./templates";
 
 export type ChangeInfo = {
   id: string;
@@ -9,6 +11,8 @@ export type ChangeInfo = {
   path: string;
 };
 
+const CHANGE_ID_PATTERN = /^(?:[Cc]\d{3}_)?[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
 const isDirectory = (path: string) => {
   try {
     return statSync(path).isDirectory();
@@ -27,6 +31,76 @@ const parseProposal = (content: string, changeId: string) => {
   };
 };
 
+export const normalizeChangeId = (value: string) => {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^([Cc])(\d{3})_(.+)$/);
+  if (match) {
+    return `C${match[2]}_${match[3]}`;
+  }
+  return trimmed;
+};
+
+export const isValidChangeId = (value: string) => CHANGE_ID_PATTERN.test(value.trim());
+
+export const readChangeSummary = (schubDir: string, changeId: string) => {
+  const trimmed = changeId.trim();
+  if (!trimmed) {
+    throw new Error("Provide --change-id.");
+  }
+
+  if (!isValidChangeId(trimmed)) {
+    throw new Error(`Invalid change-id '${changeId}'. Use kebab-case or a C-prefixed id (e.g., C001_add-user-auth).`);
+  }
+
+  const normalized = normalizeChangeId(trimmed);
+  const changeDir = join(schubDir, "changes", normalized);
+  const proposalPath = join(changeDir, "proposal.md");
+
+  if (!existsSync(proposalPath)) {
+    throw new Error(
+      `Required change files missing:\n  - ${proposalPath}\nCreate the change proposal before scaffolding docs.`,
+    );
+  }
+
+  const content = readFileSync(proposalPath, "utf8");
+  const parsed = parseProposal(content, normalized);
+
+  return {
+    changeId: normalized,
+    changeTitle: parsed.title,
+    changeDir,
+    proposalPath,
+  };
+};
+
+export const updateChangeStatus = (schubDir: string, changeId: string, status: string) => {
+  const nextStatus = status.trim();
+  if (!nextStatus) {
+    throw new Error("Provide --status.");
+  }
+
+  const summary = readChangeSummary(schubDir, changeId);
+  const content = readFileSync(summary.proposalPath, "utf8");
+  const statusMatch = content.match(/^\*\*Status\*\*:\s*(.+)$/m);
+  const previousStatus = statusMatch?.[1]?.trim();
+
+  if (!previousStatus) {
+    throw new Error(
+      `Proposal status not found in ${summary.proposalPath}.\nAdd a '**Status**: <value>' line before updating status.`,
+    );
+  }
+
+  const updated = content.replace(/^\*\*Status\*\*:\s*(.+)$/m, `**Status**: ${nextStatus}`);
+  writeFileSync(summary.proposalPath, updated, "utf8");
+
+  return {
+    changeId: summary.changeId,
+    proposalPath: summary.proposalPath,
+    previousStatus,
+    status: nextStatus,
+  };
+};
+
 const changeNumber = (id: string) => {
   const match = id.match(/\d+/);
   return match ? Number(match[0]) : Number.POSITIVE_INFINITY;
@@ -113,15 +187,20 @@ const nextChangePrefix = (schubDir: string) => {
 
 const CHANGE_PREFIX = "C";
 
-const PROPOSAL_TEMPLATE_PATH = fileURLToPath(
+const BUNDLED_PROPOSAL_TEMPLATE_PATH = fileURLToPath(
   new URL("../templates/create-proposal/proposal-template.md", import.meta.url),
 );
 
-const readProposalTemplate = () => {
+const readProposalTemplate = (schubDir: string) => {
+  const templatePath = resolveTemplatePath(
+    schubDir,
+    join("create-proposal", "proposal-template.md"),
+    BUNDLED_PROPOSAL_TEMPLATE_PATH,
+  );
   try {
-    return readFileSync(PROPOSAL_TEMPLATE_PATH, "utf8");
+    return readFileSync(templatePath, "utf8");
   } catch {
-    throw new Error(`[ERROR] Template not found: ${PROPOSAL_TEMPLATE_PATH}`);
+    throw new Error(`[ERROR] Template not found: ${templatePath}`);
   }
 };
 
@@ -147,28 +226,7 @@ const changeExists = (schubDir: string, changeId: string) => {
   return false;
 };
 
-export const resolveChangeRoot = (startDir: string = process.cwd()) => {
-  const start = resolve(startDir);
-  const fallback = join(start, ".schub");
-  let current = start;
-
-  while (true) {
-    if (basename(current) === ".schub" && isDirectory(current)) {
-      return current;
-    }
-
-    const candidate = join(current, ".schub");
-    if (isDirectory(candidate)) {
-      return candidate;
-    }
-
-    const parent = dirname(current);
-    if (parent === current) {
-      return fallback;
-    }
-    current = parent;
-  }
-};
+export const resolveChangeRoot = resolveSchubRoot;
 
 export const createChange = (
   schubDir: string,
@@ -217,7 +275,7 @@ export const createChange = (
     throw new Error(`Change '${changeId}' already exists under ${schubDir}. Choose a unique id or pass --overwrite.`);
   }
 
-  const template = readProposalTemplate();
+  const template = readProposalTemplate(schubDir);
   const today = new Date().toISOString().split("T")[0];
   const rendered = template
     .replace("{{CHANGE_TITLE}}", title)

package/src/clipboard.ts

@@ -0,0 +1,5 @@
+import { spawnSync } from "node:child_process";
+
+export const copyToClipboard = (value: string) => {
+  spawnSync("pbcopy", [], { input: value });
+};