@bakit-org/ai-sdlc-cli 0.1.1 → 0.1.3

package/README.md

@@ -7,10 +7,13 @@ Command-line installer for the ai-sdlc Claude Code harness. It puts the BA / Dev
 ```sh
 npm install -g @bakit-org/ai-sdlc-cli       # installs the `ai-sdlc` command
 gh auth login                               # or export GH_TOKEN=... (needs read access to the kit repository)
-cd ~/projects && ai-sdlc init               # guided install: pick a project, review, apply
-ai-sdlc doctor --project <path>             # confirm the install is intact
+mkdir my-project && cd my-project           # or any existing project folder
+ai-sdlc init                                # guided install into this folder: checks access, review, apply
+ai-sdlc doctor                              # confirm the install is intact
 ```
 
+Later, to bring a project up to date: `cd` into it and run `ai-sdlc update` (guided, with a review before anything is written). Bare `ai-sdlc` opens a menu for the current folder.
+
 Scripted, or without network access:
 
 ```sh
@@ -48,11 +51,11 @@ Failures are plain messages: an invalid or expired token, a repository you canno
 
 ## Choosing the project
 
-Without `--project` the CLI lists the git repositories directly under the current directory (and its parent), or under `--root`, plus an "enter a path" option. It shows the full plan and asks before writing. In scripts and CI pass `--project <path> --yes`; without a terminal the CLI refuses to guess and exits with `2`.
+Without `--project`, `init` and `update` in a terminal act on the current folder. Plain mode (`--no-tui`) does too for `update`, `doctor` and `uninstall` when ai-sdlc is installed there; otherwise it lists the git repositories directly under the current directory (and its parent), or under `--root`, plus an "enter a path" option. It shows the full plan and asks before writing. In scripts and CI pass `--project <path> --yes`; without a terminal the CLI refuses to guess and exits with `2`.
 
 ## Interactive mode
 
-In a terminal, `ai-sdlc init` is a guided install: a gradient banner, an environment check, a filterable project list (git repositories next to you plus recent projects, with `installed` / `not installed` / `no .git` badges), a review of what will change, a progress bar and a result panel with next steps. Running `ai-sdlc` with no command opens a menu, and `update`, `doctor` and `uninstall` print coloured result views. Esc or Ctrl-C at any step writes nothing and restores the terminal.
+In a terminal, `ai-sdlc init` is a guided install into the current folder and `ai-sdlc update` is the same guided flow for an installed project: a gradient banner, an environment check (including read access to the kit), a review of what will change, a progress bar and a result panel with next steps. Run it from the home directory or a filesystem root, or pass `--root <dir>`, and it shows a filterable project list instead (git repositories next to you plus recent projects, with `installed` / `not installed` / `no .git` badges). Running `ai-sdlc` with no command opens a menu, and `doctor` and `uninstall` print coloured result views. Esc or Ctrl-C at any step writes nothing and restores the terminal.
 
 It switches itself off for `--json`, `--yes`, `--no-tui`, `TERM=dumb` and whenever stdin or stdout is not a terminal; then the plain output and exit codes apply. Colours follow `NO_COLOR` and the terminal's capability, with an ASCII fallback. Details and key bindings: [docs/tui.md](docs/tui.md).
 

package/docs/tui.md

@@ -8,7 +8,8 @@ When you run the CLI in a terminal it can guide you with interactive screens tha
 |---|---|---|
 | `ai-sdlc init` | guided install (below) | same as `install` |
 | `ai-sdlc` (no command) | menu: Install, Update, Doctor, Uninstall, Quit | usage text, exit `2` |
-| `ai-sdlc update`, `doctor`, `uninstall` | coloured result views (checklist, panels); prompts as before | plain text |
+| `ai-sdlc update` | the same guided flow as `init` (current folder, review, progress, result; "Up to date" when there is nothing to do) | plain text |
+| `ai-sdlc doctor`, `uninstall` | coloured result views (checklist, panels); prompts as before | plain text |
 | `ai-sdlc install` | unchanged (numbered picker, `[y/N]`) | unchanged |
 
 "In a terminal" means stdin and stdout are both terminals. Interactive mode is never used when any of these is true, and the plain behaviour (output, prompts, exit codes `0`/`1`/`2`) is unchanged:
@@ -22,7 +23,7 @@ When you run the CLI in a terminal it can guide you with interactive screens tha
 ## The guided install (`ai-sdlc init`)
 
 1. **Banner and checks.** A banner, a dim status line (`Using: node 24 | git ✔ | kit source: bundle file`) and one line per check: Node version, git, and the kit source. With `--from-bundle <file>` the source is that file. Without it the source is the GitHub release of the payload repository and two more checks run (with the spinner): `GitHub token` (shows only where it was found, for example `found via GH_TOKEN`) and `Access to <owner>/<repo>`. If either fails, the failure line explains it (owner contact for missing read access) and offers `--from-bundle <file>`; the run ends with exit `1` before the project list and nothing is written. The release is then downloaded behind a spinner, verified and read. Ctrl-C or Esc during either spinner cancels it immediately (the request and any helper process are stopped, temporary files removed; exit `1`, nothing written). Further checks plug in through the `extraChecks` list of `runPreflight` in `lib/tui/flows/preflight.js`.
-2. **Project.** A list of git repositories found one level under `--root` (default: the current directory and its parent) plus recently used projects, newest first. Each row has a badge: `not installed`, `installed vX → update`, or `no .git ⚠`. Type to filter; `Enter a path…` opens a path field with Tab / Shift-Tab completion. `~`, files, missing paths and filesystem roots are refused with an inline message.
+2. **Project.** The current folder, unless you pass `--project`, or `--root` (picker below), or the current folder cannot be a project (home directory, filesystem root; the picker then opens with the reason). With the current folder a problem such as "already installed" (init) or "not installed" (update) ends the run with a message. The picker is a list of git repositories found one level under `--root` (default: the current directory and its parent) plus recently used projects, newest first. Each row has a badge: `not installed`, `installed vX → update`, or `no .git ⚠`. Type to filter; `Enter a path…` opens a path field with Tab / Shift-Tab completion. `~`, files, missing paths and filesystem roots are refused with an inline message.
 3. **Review.** What will happen by class (managed files, starter files, the `CLAUDE.md` block, hooks) with a note that only the marked block of `CLAUDE.md` is managed. `d` toggles the full file list. Nothing has been written at this point.
 4. **Install.** The project lock is taken, the plan is computed again under the lock, and the changes are applied with a progress bar showing the current file.
 5. **Result.** What was written and the next steps: open the folder in Claude Code, fill in `ai-sdlc/project.md`, run `ai-sdlc doctor`.

package/lib/commands.js

@@ -12,6 +12,7 @@ const { buildCommandPlan } = require('./command-plan');
 const { applyPlan } = require('./apply-plan');
 const { createPrompter, confirm, pickProject } = require('./project-picker');
 const { runDoctor } = require('./doctor');
+const { readManifest } = require('./manifest');
 const { planLines, planResult, doctorLines } = require('./cli-output');
 const { shouldUseTui, shouldRunWizard } = require('./tui/launch');
 
@@ -54,6 +55,16 @@ function requireNonInteractiveInputs(command, flags, io) {
   return false;
 }
 
+// Without --project (or --root), update/doctor/uninstall act on the current folder when ai-sdlc is installed there.
+function installedHere(command, flags, io) {
+  if (command === 'install' || flags.root) return undefined;
+  try {
+    return readManifest(io.cwd) ? io.cwd : undefined;
+  } catch (_) {
+    return io.cwd; // a manifest file is there but unreadable: let the command report why
+  }
+}
+
 async function runProjectCommand(command, flags, io, say) {
   const interactive = requireNonInteractiveInputs(command, flags, io);
   const log = (line = '') => (flags.json ? undefined : say.stdout.write(`${line}\n`));
@@ -69,7 +80,7 @@ async function runProjectCommand(command, flags, io, say) {
     }
     const bundleWarnings = bundle ? [...bundle.warnings] : [];
     const target = await pickProject({
-      project: flags.project, root: flags.root, cwd: io.cwd, home: io.home, prompter,
+      project: flags.project || installedHere(command, flags, io), root: flags.root, cwd: io.cwd, home: io.home, prompter,
       output: flags.json ? { write() {} } : say.stdout,
     });
     const project = target.dir;
@@ -127,13 +138,13 @@ function emitJson(flags, say, result, code) {
 
 // Messages can embed repo-controlled paths: on a terminal show control characters as text (line breaks kept).
 const forTerminal = (text, stream) => (stream && stream.isTTY ? String(text).split('\n').map((l) => require('./tui/sanitize').sanitize(l)).join('\n') : text);
-const runWizard = (flags, io) => require('./tui/flows/init-flow').runInitFlow({ flags, io, cliVersion: pkg.version });
+const runWizard = (flags, io, command = 'install') => require('./tui/flows/init-flow').runInitFlow({ flags, io, cliVersion: pkg.version, command });
 
 // Bare `ai-sdlc` in a terminal: pick an action, then run it like the typed command.
 async function runMenu(flags, io, say) {
   const { command, installedHere } = await require('./tui/flows/menu-flow').chooseAction({ io });
   if (command === 'quit') return 0;
-  if (command === 'install' && shouldRunWizard(flags, io)) return runWizard(flags, io);
+  if ((command === 'install' || command === 'update') && shouldRunWizard(flags, io)) return runWizard(flags, io, command);
   const target = installedHere && !flags.project && command !== 'install' ? { ...flags, project: io.cwd } : flags;
   return runProjectCommand(command, target, io, say);
 }
@@ -159,7 +170,7 @@ async function run(argv, env = {}) {
         say.stderr.write(HELP);
         return 2;
       default:
-        if (flags.init && shouldRunWizard(flags, io)) return await runWizard(flags, io);
+        if ((flags.init || parsed.command === 'update') && shouldRunWizard(flags, io)) return await runWizard(flags, io, parsed.command === 'update' ? 'update' : 'install');
         return await runProjectCommand(parsed.command, flags, io, say);
     }
   } catch (err) {

package/lib/tui/flows/init-flow.js

@@ -1,8 +1,11 @@
 'use strict';
-// The guided install: banner, environment check, project, review, progress, result.
-// Nothing touches the project until the review is confirmed; the apply layer is
-// only called after that.
-const { CliError } = require('../../errors');
+// The guided install and update: banner, environment check, project, review,
+// progress, result. The project is the current folder unless --project or --root
+// says otherwise. Nothing touches the project until the review is confirmed; the
+// apply layer is only called after that.
+const { CliError, UsageError } = require('../../errors');
+const { readManifest } = require('../../manifest');
+const { compare } = require('../../semver');
 const { loadReleaseBundle } = require('../../release-source');
 const { githubChecks } = require('../../github-checks');
 const { validateTarget } = require('../../project-picker');
@@ -23,11 +26,15 @@ const { bannerLines } = require('./intro');
 const { sessionOptions } = require('./session-options');
 const { pickProjectStep } = require('./pick-project-step');
 const { reviewBody } = require('./review-view');
-const { installedPanel } = require('./result-views');
+const { installedPanel, updatedPanel, upToDatePanel } = require('./result-views');
 const { readRecent, rememberProject } = require('./recent-projects');
 const { shortPath } = require('./project-choices');
 
 const CHANGED_NOTE = 'The project changed after the plan was made; this is the updated plan.';
+const COPY = {
+  install: { confirm: 'Install', progress: 'Installing', pick: 'Select the project to install into' },
+  update: { confirm: 'Update', progress: 'Updating', pick: 'Select the project to update' },
+};
 
 function preflightLines(theme, items) {
   return items.map((i) => {
@@ -36,7 +43,32 @@ function preflightLines(theme, items) {
   });
 }
 
-async function wizard({ session, flags, io, cliVersion }) {
+// The installed manifest of a folder, or null. A manifest that cannot be read counts as installed so planning reports why.
+function installedManifest(dir) {
+  try {
+    return readManifest(dir);
+  } catch (_) {
+    return {};
+  }
+}
+
+// The folder the user is standing in, when it can be the project. For update it must already hold an
+// install (a subfolder of an installed repository gets the picker instead of a second, nested install).
+function currentFolder(io, command) {
+  let target;
+  try {
+    target = validateTarget(io.cwd, { cwd: io.cwd, home: io.home });
+  } catch (err) {
+    if (!(err instanceof UsageError)) throw err;
+    return { target: null, notice: err.message };
+  }
+  if (command === 'update' && !installedManifest(target.dir)) {
+    return { target: null, notice: `ai-sdlc is not installed in ${target.dir}. Pick the project to update, or run "ai-sdlc init" here.` };
+  }
+  return { target, notice: '' };
+}
+
+async function wizard({ session, flags, io, cliVersion, command }) {
   const { theme } = session;
   const preflight = await withSpinner(session, 'Checking your environment...', (signal) => runPreflight({
     flags, cwd: io.cwd, execFile: io.execFile, env: io.env, signal, extraChecks: io.extraChecks || (flags.fromBundle ? [] : githubChecks(io.github)),
@@ -52,22 +84,37 @@ async function wizard({ session, flags, io, cliVersion }) {
   for (const w of bundle.warnings) session.commit([`  ${theme.paint('warn', `${theme.sym.warn} ${sanitize(w)}`)}`]);
 
   const recents = readRecent({ env: io.env, home: io.home });
-  let notice = '';
+  // --project and the current folder are fixed targets: a problem with them ends the run instead of re-asking.
+  const here = flags.project || flags.root ? { target: null, notice: '' } : currentFolder(io, command);
+  const fixed = flags.project ? validateTarget(flags.project, { cwd: io.cwd, home: io.home }) : here.target;
+  let notice = here.notice;
   for (;;) {
-    const target = flags.project ? validateTarget(flags.project, { cwd: io.cwd, home: io.home }) : await pickProjectStep({ session, cwd: io.cwd, home: io.home, root: flags.root, recents, notice });
+    const target = fixed || await pickProjectStep({ session, cwd: io.cwd, home: io.home, root: flags.root, recents, notice, title: COPY[command].pick });
     notice = '';
     if (target === BACK) throw new Cancelled('escape');
-    let plan;
+    if (command === 'update' && fixed && !installedManifest(target.dir)) {
+      throw new CliError(`ai-sdlc is not installed in ${target.dir}; run "ai-sdlc init" to install it first`);
+    }
+    let planned;
     try {
-      ({ plan } = buildCommandPlan({ command: 'install', flags, project: target.dir, bundle, cliVersion }));
+      planned = buildCommandPlan({ command, flags, project: target.dir, bundle, cliVersion });
     } catch (err) {
       // For example "already installed": say so and let the user pick another project.
-      if (flags.project || !(err instanceof CliError)) throw err;
+      if (fixed || !(err instanceof CliError)) throw err;
       notice = err.message;
       continue;
     }
-    if ((await reviewAndInstall({ session, flags, io, cliVersion, bundle, target, plan })) === BACK) {
-      if (flags.project) throw new Cancelled('escape');
+    const { plan, prior } = planned;
+    // The manifest is always rewritten; the same release with no other change is "nothing to do".
+    const sameRelease = command === 'update' && prior && prior.payload_version === plan.payloadVersion;
+    if (sameRelease && !plan.actions.some((a) => a.kind !== 'manifest' && (a.write || a.remove))) {
+      const stale = inspect(target.dir, JOURNAL_REL).exists ? [`${JOURNAL_REL} exists: an earlier run was interrupted or another run is active`] : [];
+      session.commit(upToDatePanel({ theme, width: session.ctx().width, project: shortPath(target.dir, io.home), version: bundle.version, warnings: stale }));
+      return 0;
+    }
+    const fromVersion = command === 'update' && prior ? prior.payload_version : '';
+    if ((await reviewAndApply({ session, flags, io, cliVersion, bundle, target, plan, command, fromVersion })) === BACK) {
+      if (fixed) throw new Cancelled('escape');
       continue;
     }
     return 0;
@@ -75,17 +122,18 @@ async function wizard({ session, flags, io, cliVersion }) {
 }
 
 // Review loop: if the project no longer matches the reviewed plan once the lock is held, review again.
-async function reviewAndInstall({ session, flags, io, cliVersion, bundle, target, plan: first }) {
+async function reviewAndApply({ session, flags, io, cliVersion, bundle, target, plan: first, command, fromVersion }) {
   let plan = first;
   const warnings = inspect(target.dir, JOURNAL_REL).exists ? [`${JOURNAL_REL} exists: an earlier run was interrupted or another run is active`] : [];
+  if (fromVersion && compare(first.payloadVersion, fromVersion) === -1) warnings.push(`this release (${first.payloadVersion}) is older than the installed one (${fromVersion})`);
   for (;;) {
     const current = plan;
     const review = createConfirm({
-      title: 'Review', confirmLabel: 'Install', detailsToggle: true, guardMs: io.confirmGuardMs,
-      body: (state, ctx) => reviewBody({ theme: ctx.theme, project: truncateMiddle(sanitize(shortPath(target.dir, io.home)), ctx.width - 30), plan: current, bundle, hasGit: target.hasGit, warnings }, state),
+      title: 'Review', confirmLabel: COPY[command].confirm, detailsToggle: true, guardMs: io.confirmGuardMs,
+      body: (state, ctx) => reviewBody({ theme: ctx.theme, project: truncateMiddle(sanitize(shortPath(target.dir, io.home)), ctx.width - 30), plan: current, bundle, hasGit: target.hasGit, warnings, fromVersion }, state),
     });
     if ((await session.run(review)) === BACK) return BACK;
-    const outcome = install({ session, flags, io, cliVersion, bundle, project: target.dir, reviewed: current });
+    const outcome = apply({ session, flags, io, cliVersion, bundle, project: target.dir, reviewed: current, command, fromVersion });
     if (!outcome.changed) return 0;
     plan = outcome.plan;
     if (!warnings.includes(CHANGED_NOTE)) warnings.push(CHANGED_NOTE);
@@ -94,29 +142,30 @@ async function reviewAndInstall({ session, flags, io, cliVersion, bundle, target
 
 // Lock, plan again under the lock, apply with a progress bar, release.
 // Returns { changed: true, plan } without writing when the fresh plan differs from the reviewed one.
-function install({ session, flags, io, cliVersion, bundle, project, reviewed }) {
-  const lock = acquireLock(project, 'install', { force: Boolean(flags.force) });
+function apply({ session, flags, io, cliVersion, bundle, project, reviewed, command, fromVersion }) {
+  const lock = acquireLock(project, command, { force: Boolean(flags.force) });
   try {
-    const { plan } = buildCommandPlan({ command: 'install', flags, project, bundle, cliVersion });
+    const { plan } = buildCommandPlan({ command, flags, project, bundle, cliVersion });
     if (planSignature(plan) !== planSignature(reviewed)) return { changed: true, plan };
     const shown = truncateMiddle(sanitize(shortPath(project, io.home)), session.ctx().width - 14);
     session.commit([`  ${session.theme.paint('ok', session.theme.sym.ok)} Project  ${session.theme.paint('dim', shown)}`]);
     const show = ({ done, total, path: rel }) => session.draw((ctx) => [
-      '', `  Installing ai-sdlc ${sanitize(bundle.version)}`, renderProgress({ theme: ctx.theme, width: ctx.width, done, total, label: sanitize(rel || 'preparing') }),
+      '', `  ${COPY[command].progress} ai-sdlc ${sanitize(bundle.version)}`, renderProgress({ theme: ctx.theme, width: ctx.width, done, total, label: sanitize(rel || 'preparing') }),
     ]);
-    applyPlan(project, plan, 'install', lock, { onProgress: show });
+    applyPlan(project, plan, command, lock, { onProgress: show });
     rememberProject(project, { env: io.env, home: io.home });
-    session.commit(installedPanel({ theme: session.theme, width: session.ctx().width, project: shortPath(project, io.home), plan, version: bundle.version }));
+    const panel = command === 'update' ? updatedPanel : installedPanel;
+    session.commit(panel({ theme: session.theme, width: session.ctx().width, project: shortPath(project, io.home), plan, version: bundle.version, fromVersion }));
     return { changed: false };
   } finally {
     lock.release();
   }
 }
 
-async function runInitFlow({ flags, io, cliVersion }) {
+async function runInitFlow({ flags, io, cliVersion, command = 'install' }) {
   const theme = createTheme({ env: io.env, stream: io.stdout });
   try {
-    return await withSession(sessionOptions(io, theme), (session) => wizard({ session, flags, io, cliVersion }));
+    return await withSession(sessionOptions(io, theme), (session) => wizard({ session, flags, io, cliVersion, command }));
   } catch (err) {
     if (err instanceof Cancelled) throw new CliError(err.reason === 'interrupt' ? 'interrupted; nothing was changed' : 'cancelled; nothing was changed');
     throw err;

package/lib/tui/flows/pick-project-step.js

@@ -9,7 +9,7 @@ const { createPathInput } = require('../widgets/path-input');
 const { buildProjectItems, PATH_CHOICE } = require('./project-choices');
 
 // Resolves to { dir, hasGit } or BACK.
-async function pickProjectStep({ session, cwd, home, root, recents, notice: initialNotice = '' }) {
+async function pickProjectStep({ session, cwd, home, root, recents, notice: initialNotice = '', title = 'Select the project to install into' }) {
   const items = buildProjectItems({ cwd, root, home, recents, theme: session.theme });
   const maxVisible = Math.max(3, Math.min(10, session.rows - 10));
   const validate = (text) => validateTarget(text, { cwd, home });
@@ -17,7 +17,7 @@ async function pickProjectStep({ session, cwd, home, root, recents, notice: init
   let mode = 'list';
   for (;;) {
     if (mode === 'list') {
-      const picked = await session.run(createSelectList({ title: 'Select the project to install into', items, maxVisible, notice, placeholder: 'Type to filter projects' }));
+      const picked = await session.run(createSelectList({ title, items, maxVisible, notice, placeholder: 'Type to filter projects' }));
       if (picked === BACK) return BACK;
       if (picked.item.value === PATH_CHOICE) {
         mode = 'path';

package/lib/tui/flows/result-views.js

@@ -86,4 +86,17 @@ function installedPanel({ theme, width, project, plan, version }) {
   return ['', ...renderPanel({ theme, width, tone: 'ok', title: `${theme.sym.ok} Installed`, lines })];
 }
 
-module.exports = { doctorView, planView, planRows, doneView, installedPanel, counts };
+// Closing panel of the guided update.
+function updatedPanel({ theme, width, project, plan, version, fromVersion }) {
+  const written = plan.actions.filter((a) => a.write).length;
+  const lines = [`ai-sdlc ${fromVersion ? `${sanitize(fromVersion)} -> ` : ''}${sanitize(version)} in ${truncateMiddle(sanitize(project), width - 30)}`, `${written} file(s) written (${counts(plan.actions)})`, '', 'Run `ai-sdlc doctor` in the project to check it.'];
+  if (plan.actions.some((a) => a.action === 'write-new')) lines.push('', 'Review the *.new files next to files you modified and merge by hand.');
+  return ['', ...renderPanel({ theme, width, tone: 'ok', title: `${theme.sym.ok} Updated`, lines })];
+}
+
+function upToDatePanel({ theme, width, project, version, warnings = [] }) {
+  const lines = [`ai-sdlc ${sanitize(version)} is already installed in ${truncateMiddle(sanitize(project), width - 40)}`, ...warnings.map((w) => `${theme.sym.warn} ${sanitize(w)}`)];
+  return ['', ...renderPanel({ theme, width, tone: warnings.length ? 'warn' : 'ok', title: `${theme.sym.ok} Up to date`, lines })];
+}
+
+module.exports = { updatedPanel, upToDatePanel, doctorView, planView, planRows, doneView, installedPanel, counts };

package/lib/tui/flows/review-view.js

@@ -20,8 +20,8 @@ function tallyByClass(plan, bundle) {
 
 const breakdown = (by) => Object.entries(by).map(([k, v]) => `${sanitize(k)} ${v}`).join(', ');
 
-// ctx: { theme, project, plan, bundle, hasGit, warnings }
-function reviewBody({ theme, project, plan, bundle, hasGit, warnings = [] }, state) {
+// ctx: { theme, project, plan, bundle, hasGit, warnings, fromVersion }
+function reviewBody({ theme, project, plan, bundle, hasGit, warnings = [], fromVersion = '' }, state) {
   const dim = (s) => theme.paint('dim', s);
   const tally = tallyByClass(plan, bundle);
   const block = plan.actions.find((a) => a.kind === 'block');
@@ -29,7 +29,8 @@ function reviewBody({ theme, project, plan, bundle, hasGit, warnings = [] }, sta
   const hookCount = bundle ? bundle.hooks.length : 0;
   const row = (name, text, extra) => `  ${theme.paint('accent', padEnd(name, 10))} ${padEnd(text, 18)} ${dim(extra)}`;
 
-  const lines = [`${theme.paint('bold', `ai-sdlc ${sanitize(plan.payloadVersion)}`)} ${theme.sym.arrow} ${sanitize(project)}`, ''];
+  const version = fromVersion ? `${sanitize(fromVersion)} ${theme.sym.arrow} ${sanitize(plan.payloadVersion)}` : sanitize(plan.payloadVersion);
+  const lines = [`${theme.paint('bold', `ai-sdlc ${version}`)} ${theme.sym.arrow} ${sanitize(project)}`, ''];
   lines.push(row('managed', plural(tally.managed.total, 'file'), breakdown(tally.managed.by)));
   lines.push(row('user-once', plural(tally['user-once'].total, 'starter file'), breakdown(tally['user-once'].by)));
   lines.push(row('block', 'CLAUDE.md block', block ? sanitize(block.action) : 'unchanged'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakit-org/ai-sdlc-cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Installs, updates, checks and removes the ai-sdlc Claude Code harness in a project repository.",
   "license": "MIT",
   "bin": {