@pugi/cli 0.1.0-beta.10 → 0.1.0-beta.12

package/dist/core/repl/onboarding-state.js

@@ -0,0 +1,297 @@
+/**
+ * Project onboarding state for the Pugi REPL.
+ *
+ * Inspired by Claude Code's projectOnboardingState pattern (the leaked
+ * upstream file ships a 4-flag memoized check called on every prompt
+ * submit). Independent implementation: the storage location, the steps,
+ * the reset path, and the cap counter are all Pugi-shaped.
+ *
+ * # Why this exists
+ *
+ * The REPL's status bar can flash a `setup needed: run /init` hint when
+ * a workspace is still ungoverned (no PUGI.md, no skills installed). The
+ * hint must NEVER show on a workspace where the operator already ran the
+ * interview - otherwise the prompt becomes nag-noise. Three layered
+ * short-circuits guarantee that:
+ *
+ *   1. `hasCompletedOnboarding === true` in `~/.pugi/state.json` -> stop.
+ *      The interview's final phase writes this flag once; subsequent
+ *      REPL boots short-circuit at the global ledger and never even
+ *      stat the workspace.
+ *   2. `onboardingSeenCount >= 4` -> stop. If the operator dismissed
+ *      the hint four times without finishing the interview, assume they
+ *      do not want it. The bar stays clean from boot 5 onward.
+ *   3. `PUGI_IS_DEMO=1` -> stop. The demo / snapshot recorder sets this
+ *      so the screen capture stays free of onboarding chrome.
+ *
+ * If none short-circuit, the function checks the per-workspace steps
+ * (`PUGI.md` present, at least one skill installed, auth ok, workspace
+ * dir bound) and returns `true` only when at least one step is still
+ * incomplete.
+ *
+ * # Storage shape
+ *
+ * The global state file is JSON-on-disk at
+ * `~/.pugi/state.json`. It carries two scalars:
+ *
+ *   {
+ *     "hasCompletedOnboarding": boolean,
+ *     "onboardingSeenCount": integer >= 0
+ *   }
+ *
+ * The file is read at most once per process (memoized) so the hot path
+ * is in-memory. `incrementSeenCount()` re-reads the file before
+ * mutating to avoid clobbering a sibling Pugi process's increment
+ * (concurrent REPLs in two terminals). Atomic-ish: we write to
+ * `state.json.tmp` then rename. A race that overwrites another
+ * increment is benign - the worst case is a single missed +1 across
+ * two siblings.
+ *
+ * # Reset path
+ *
+ * `rm ~/.pugi/state.json` resets every flag. Tests rely on this:
+ * `resetOnboardingStateForTests(stateDir)` is the public helper that
+ * removes the file and clears the memoization cache.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const DEFAULT_STATE = Object.freeze({
+    hasCompletedOnboarding: false,
+    onboardingSeenCount: 0,
+});
+/** Hard cap; once the operator has seen the hint this many times we stop. */
+export const ONBOARDING_SEEN_CAP = 4;
+/**
+ * Singleton memoization cache - cleared by `resetMemoizationForTests`.
+ * Keyed by stateDir so concurrent specs in the same process do not
+ * interfere with each other.
+ */
+const SHOULD_SHOW_CACHE = new Map();
+const PERSISTED_STATE_CACHE = new Map();
+/**
+ * Default fs implementation - the real `node:fs` module wrapped into
+ * the minimal surface this file uses.
+ */
+const REAL_FS = {
+    existsSync,
+    readFileSync: (path, encoding) => readFileSync(path, encoding),
+    writeFileSync: (path, data, options) => writeFileSync(path, data, options),
+    mkdirSync: (path, opts) => {
+        mkdirSync(path, opts);
+    },
+    renameSync,
+    rmSync: (path, opts) => rmSync(path, opts),
+    readdirSync: (path) => readdirSync(path),
+};
+/**
+ * Compute the four Pugi-specific onboarding steps for the given
+ * workspace. Pure: the only side effect is the filesystem probe (which
+ * tests stub via `probes.fs`).
+ */
+export function getSteps(probes) {
+    const fs = probes.fs ?? REAL_FS;
+    const pugiDirPath = join(probes.cwd, '.pugi');
+    const hasWorkspaceDir = fs.existsSync(pugiDirPath);
+    const hasPugiMd = fs.existsSync(join(probes.cwd, 'PUGI.md')) ||
+        fs.existsSync(join(pugiDirPath, 'PUGI.md'));
+    const skillsDir = join(pugiDirPath, 'skills');
+    const hasSkill = fs.existsSync(skillsDir) && !isEmptyDir(skillsDir, fs);
+    return [
+        {
+            key: 'workspace',
+            text: 'Bind a workspace by running pugi init',
+            isComplete: hasWorkspaceDir,
+            isEnabled: true,
+        },
+        {
+            key: 'pugimd',
+            text: 'Run /init to write PUGI.md with project context',
+            isComplete: hasPugiMd,
+            isEnabled: hasWorkspaceDir,
+        },
+        {
+            key: 'skills',
+            text: 'Install at least one skill under .pugi/skills/',
+            isComplete: hasSkill,
+            isEnabled: hasWorkspaceDir,
+        },
+        {
+            key: 'auth',
+            text: 'Run pugi login to authenticate',
+            isComplete: probes.authOk,
+            isEnabled: true,
+        },
+    ];
+}
+/**
+ * Roll-up over the steps. True when every ENABLED step is complete -
+ * disabled steps (e.g. `pugimd` before `workspace` is set up) are
+ * excluded so the operator does not get stuck on a step they cannot
+ * action yet.
+ */
+export function isOnboardingComplete(probes) {
+    const steps = getSteps(probes);
+    return steps
+        .filter((s) => s.isEnabled)
+        .every((s) => s.isComplete);
+}
+/**
+ * The exported gate the REPL status bar consults. Memoized per
+ * stateDir; the hot path is one map lookup once the first call has run.
+ */
+export function shouldShowOnboarding(probes) {
+    const stateDir = probes.stateDir ?? defaultStateDir();
+    const cached = SHOULD_SHOW_CACHE.get(stateDir);
+    if (cached !== undefined)
+        return cached;
+    const persisted = loadPersistedState(stateDir, probes.fs ?? REAL_FS);
+    const isDemo = probes.isDemoOverride ?? (process.env.PUGI_IS_DEMO === '1');
+    if (persisted.hasCompletedOnboarding) {
+        SHOULD_SHOW_CACHE.set(stateDir, false);
+        return false;
+    }
+    if (persisted.onboardingSeenCount >= ONBOARDING_SEEN_CAP) {
+        SHOULD_SHOW_CACHE.set(stateDir, false);
+        return false;
+    }
+    if (isDemo) {
+        SHOULD_SHOW_CACHE.set(stateDir, false);
+        return false;
+    }
+    const verdict = !isOnboardingComplete(probes);
+    SHOULD_SHOW_CACHE.set(stateDir, verdict);
+    return verdict;
+}
+/**
+ * Idempotent setter: if the workspace is now fully onboarded, flip the
+ * persisted flag. Cheap to call on every prompt submit because the
+ * fast path short-circuits on the in-memory cache.
+ *
+ * The "maybe" prefix mirrors the upstream pattern: a no-op is the
+ * common case; the write only fires once when the operator's most
+ * recent action just completed the ladder.
+ */
+export function maybeMarkOnboardingComplete(probes) {
+    const stateDir = probes.stateDir ?? defaultStateDir();
+    const fs = probes.fs ?? REAL_FS;
+    const persisted = loadPersistedState(stateDir, fs);
+    if (persisted.hasCompletedOnboarding)
+        return;
+    if (!isOnboardingComplete(probes))
+        return;
+    persistState(stateDir, fs, { ...persisted, hasCompletedOnboarding: true });
+    // Invalidate the cache so the next `shouldShowOnboarding` call sees
+    // the new value without restarting the process.
+    SHOULD_SHOW_CACHE.delete(stateDir);
+}
+/**
+ * Increment the seen counter. The REPL status bar calls this once per
+ * boot where it actually rendered the hint. After
+ * `ONBOARDING_SEEN_CAP` increments the cap guard in
+ * `shouldShowOnboarding` flips the gate off permanently for this user.
+ */
+export function incrementOnboardingSeenCount(probes) {
+    const stateDir = probes.stateDir ?? defaultStateDir();
+    const fs = probes.fs ?? REAL_FS;
+    const persisted = loadPersistedState(stateDir, fs);
+    const next = {
+        ...persisted,
+        onboardingSeenCount: persisted.onboardingSeenCount + 1,
+    };
+    persistState(stateDir, fs, next);
+    SHOULD_SHOW_CACHE.delete(stateDir);
+}
+/**
+ * Reset every persisted flag. Tests use this via the public helper; an
+ * operator can achieve the same effect by `rm ~/.pugi/state.json`.
+ */
+export function resetOnboardingStateForTests(probes) {
+    const stateDir = probes.stateDir ?? defaultStateDir();
+    const fs = probes.fs ?? REAL_FS;
+    const file = stateFilePath(stateDir);
+    if (fs.existsSync(file)) {
+        fs.rmSync(file, { force: true });
+    }
+    SHOULD_SHOW_CACHE.delete(stateDir);
+    PERSISTED_STATE_CACHE.delete(stateDir);
+}
+/**
+ * Clear the in-memory memoization without touching the disk. The
+ * spec uses this between assertions when it wants to force a re-read.
+ */
+export function resetMemoizationForTests(stateDir) {
+    if (stateDir) {
+        SHOULD_SHOW_CACHE.delete(stateDir);
+        PERSISTED_STATE_CACHE.delete(stateDir);
+        return;
+    }
+    SHOULD_SHOW_CACHE.clear();
+    PERSISTED_STATE_CACHE.clear();
+}
+/* ------------------------------------------------------------------ */
+/* Internal helpers                                                   */
+/* ------------------------------------------------------------------ */
+function defaultStateDir() {
+    return join(homedir(), '.pugi');
+}
+function stateFilePath(stateDir) {
+    return join(stateDir, 'state.json');
+}
+function loadPersistedState(stateDir, fs) {
+    const cached = PERSISTED_STATE_CACHE.get(stateDir);
+    if (cached !== undefined)
+        return cached;
+    const file = stateFilePath(stateDir);
+    if (!fs.existsSync(file)) {
+        PERSISTED_STATE_CACHE.set(stateDir, DEFAULT_STATE);
+        return DEFAULT_STATE;
+    }
+    try {
+        const raw = fs.readFileSync(file, 'utf8');
+        const parsed = JSON.parse(raw);
+        const normalized = {
+            hasCompletedOnboarding: parsed.hasCompletedOnboarding === true,
+            onboardingSeenCount: typeof parsed.onboardingSeenCount === 'number' &&
+                Number.isFinite(parsed.onboardingSeenCount) &&
+                parsed.onboardingSeenCount >= 0
+                ? Math.floor(parsed.onboardingSeenCount)
+                : 0,
+        };
+        PERSISTED_STATE_CACHE.set(stateDir, normalized);
+        return normalized;
+    }
+    catch {
+        // Corrupt file - treat as if it were absent. The next persist
+        // overwrites with a clean shape; we never crash the REPL boot on
+        // an unreadable state file.
+        PERSISTED_STATE_CACHE.set(stateDir, DEFAULT_STATE);
+        return DEFAULT_STATE;
+    }
+}
+function persistState(stateDir, fs, next) {
+    if (!fs.existsSync(stateDir)) {
+        fs.mkdirSync(stateDir, { recursive: true });
+    }
+    const file = stateFilePath(stateDir);
+    const tmp = `${file}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    fs.renameSync(tmp, file);
+    PERSISTED_STATE_CACHE.set(stateDir, next);
+}
+function isEmptyDir(path, fs) {
+    // An empty `skills/` directory counts as "no skill installed yet" so
+    // the onboarding step stays incomplete. The injected fs shim may
+    // omit `readdirSync` - in that case we conservatively report
+    // non-empty (the dir existed, so the operator likely did something
+    // intentional) to avoid false-positive nag.
+    if (!fs.readdirSync)
+        return false;
+    try {
+        return fs.readdirSync(path).length === 0;
+    }
+    catch {
+        return true;
+    }
+}
+//# sourceMappingURL=onboarding-state.js.map

package/dist/core/repl/session.js

@@ -663,6 +663,52 @@ export class ReplSession {
                 await this.dispatchPrivacy();
                 return verdict;
             }
+            case 'init': {
+                // β1 Sl11 → β1a r1 (real inline scaffold, 2026-05-26): invoke
+                // `scaffoldPugiWorkspace` directly so the operator gets the
+                // same .pugi/ setup they would from `pugi init` on a fresh
+                // shell. Already-initialised workspaces (every artifact already
+                // present) get the "Already initialised" copy; partial / fresh
+                // workspaces get the full Created+Skipped breakdown. Default
+                // skills install is best-effort — any error from the bundled
+                // pack is surfaced as a system line and does not break the
+                // REPL session. The dynamic import keeps the slash dispatcher
+                // free of a runtime/cli.ts cycle on every keystroke.
+                try {
+                    const { scaffoldPugiWorkspace } = await import('../../runtime/cli.js');
+                    const lines = [];
+                    const result = await scaffoldPugiWorkspace({
+                        cwd: process.cwd(),
+                        // Slash callers default to the full default-skills pack so
+                        // the in-REPL experience matches `pugi init`. Operators who
+                        // want a minimal scaffold still have the shell command.
+                        noDefaults: false,
+                        log: (line) => {
+                            const trimmed = line.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    if (result.alreadyInitialized) {
+                        this.appendSystemLine(`.pugi/ already initialised at ${result.root}. ${result.skipped.length} artefact(s) verified.`);
+                    }
+                    else {
+                        this.appendSystemLine(`Pugi initialised at ${result.root}. Created ${result.created.length} artefact(s), skipped ${result.skipped.length}.`);
+                    }
+                    if (result.defaultSkills.length > 0) {
+                        const installed = result.defaultSkills.filter((s) => s.status === 'installed').length;
+                        const skippedSkills = result.defaultSkills.filter((s) => s.status === 'skipped-existing').length;
+                        this.appendSystemLine(`Default skills: ${installed} installed, ${skippedSkills} already present.`);
+                    }
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/init failed: ${message}`);
+                }
+                return verdict;
+            }
             case 'stub': {
                 this.appendSystemLine(verdict.message);
                 return verdict;

package/dist/core/repl/slash-commands.js

@@ -62,6 +62,7 @@ export const SLASH_COMMAND_HELP = Object.freeze([
     { name: 'context', args: '', gloss: 'Show three-tier context summary (Tier 0 skeleton + Tier 1 working set)', group: 'Session' },
     { name: 'compact', args: '', gloss: 'Manual context compaction  (α6.5b)', group: 'Session', stub: true },
     { name: 'memory', args: '', gloss: 'Session memory editor  (α6.5b)', group: 'Session', stub: true },
+    { name: 'init', args: '', gloss: 'Scaffold .pugi/ in the current workspace (β1 Sl11)', group: 'Session' },
     // Pugi tools
     { name: 'web', args: '<url>', gloss: 'Fetch a URL into context', group: 'Pugi tools' },
     { name: 'diff', args: '', gloss: 'Show pending diff', group: 'Pugi tools' },
@@ -248,6 +249,13 @@ export function parseSlashCommand(input) {
             // device flow + audit identity are wired correctly).
             return { kind: 'privacy' };
         }
+        case 'init': {
+            // β1 Sl11: surface the init flow inside the REPL. Tail args
+            // are ignored — the init handler is parameterless today; `pugi
+            // init --no-defaults` is the CLI surface for skipping bundled
+            // skills.
+            return { kind: 'init' };
+        }
         case 'compact':
         case 'memory':
         case 'config':

package/dist/core/settings.js

@@ -47,6 +47,34 @@ const pugiSettingsSchema = z.object({
             .optional(),
     })
         .optional(),
+    // β1 Pl9 (#74) — per-command budget overrides. Optional. Partial
+    // overrides merge against the β1 defaults in
+    // `core/engine/budgets.ts::beta1DefaultBudgets`. The schema is
+    // intentionally loose at the leaf (positive integers) so a typo lands
+    // a deterministic `BudgetConfigError` at `resolveBudget()` instead of
+    // a Zod parse error two layers up.
+    budgets: z
+        .object({
+        code: z
+            .object({ maxTokens: z.number().int().positive().optional(), maxToolCalls: z.number().int().positive().optional() })
+            .optional(),
+        fix: z
+            .object({ maxTokens: z.number().int().positive().optional(), maxToolCalls: z.number().int().positive().optional() })
+            .optional(),
+        build: z
+            .object({ maxTokens: z.number().int().positive().optional(), maxToolCalls: z.number().int().positive().optional() })
+            .optional(),
+        plan: z
+            .object({ maxTokens: z.number().int().positive().optional(), maxToolCalls: z.number().int().positive().optional() })
+            .optional(),
+        explain: z
+            .object({ maxTokens: z.number().int().positive().optional(), maxToolCalls: z.number().int().positive().optional() })
+            .optional(),
+        review_triple: z
+            .object({ maxTokens: z.number().int().positive().optional(), maxToolCalls: z.number().int().positive().optional() })
+            .optional(),
+    })
+        .optional(),
 });
 export function loadSettings(root) {
     const settingsPath = resolve(root, '.pugi/settings.json');

package/dist/runtime/cli.js

@@ -51,7 +51,37 @@ import { dispatchEdit, } from '../core/edits/index.js';
  * packages/pugi-sdk/package.json); the publish workflow validates the
  * three are in lockstep.
  */
-const PUGI_CLI_VERSION = "0.1.0-beta.10";
+/**
+ * β1 housekeeping (#51): defensive semver sanitizer. If a future
+ * refactor moves PUGI_CLI_VERSION reading to a JSON import (resolveJson)
+ * the npm publish pipeline can leak `workspace:*` from a partially-bumped
+ * package.json — `npm publish` rewrites these but a local `pnpm pack`
+ * does not, and the failure mode is silently shipping an unsemver
+ * version that breaks `pugi --version` JSON consumers. Sanitize at the
+ * read site so even a leaked literal lands as a deterministic
+ * "0.0.0-unknown" rather than `workspace:*`.
+ */
+function sanitizeSemver(raw) {
+    if (typeof raw !== 'string')
+        return '0.0.0-unknown';
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return '0.0.0-unknown';
+    // Strip a `workspace:` / `npm:` / `file:` protocol prefix that pnpm
+    // can emit when a partial publish runs.
+    const stripped = trimmed.replace(/^(workspace:|npm:|file:)/, '');
+    // Accept anything that begins with major.minor.patch + optional
+    // prerelease/build per semver 2.0. Reject `*`, `^x`, `~x`, ranges, etc.
+    if (/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(stripped)) {
+        return stripped;
+    }
+    return '0.0.0-unknown';
+}
+// Main bumped to 0.1.0-beta.9 (PR #430 REPL-hang fix). β1a r1 rebase
+// preserves the main bump and runs it through the β1 sanitizer added
+// here so a future workspace:* leak from a partial publish lands as
+// "0.0.0-unknown" instead of corrupting `pugi --version` JSON output.
+const PUGI_CLI_VERSION = sanitizeSemver("0.1.0-beta.12");
 const handlers = {
     accounts,
     agents: dispatchAgents,
@@ -618,7 +648,15 @@ function parseArgs(argv) {
     // through to the engine. Re-routing here means `pugi <cmd> --help`
     // becomes `pugi help <cmd>` deterministically across the entire
     // command tree.
-    if (args.includes('--help') || args.includes('-h')) {
+    //
+    // β1 Tt3 carve-out: commands that ship their OWN `--help` block
+    // (login, init, ...) must keep `--help` in their args so the
+    // command-local printer fires. Without this carve-out
+    // `pugi login --help` produces the global help and the per-variant
+    // reference (`--provider device|token|env`) gets lost. The carve-out
+    // list mirrors handlers whose source carries an
+    // `args.includes('--help')` short-circuit.
+    if ((args.includes('--help') || args.includes('-h')) && !COMMAND_LOCAL_HELP.has(command)) {
         return { command: 'help', args: [command], flags, isBareInvocation: false };
     }
     return {
@@ -628,6 +666,14 @@ function parseArgs(argv) {
         isBareInvocation,
     };
 }
+/**
+ * β1 Tt3: commands that own their `--help` rendering. The bare-help
+ * redirect leaves their `--help` arg in place so the command-local
+ * printer fires instead of the global summary.
+ */
+const COMMAND_LOCAL_HELP = new Set([
+    'login',
+]);
 async function version(_args, flags, _session) {
     const payload = {
         name: 'pugi',
@@ -764,8 +810,21 @@ async function doctor(_args, flags, _session) {
         `Release guard: ${payload.releaseGuard}`,
     ].join('\n'));
 }
-async function init(_args, flags, _session) {
-    const cwd = process.cwd();
+/**
+ * Programmatic init scaffolder. Idempotent — every helper call is a
+ * `*_IfMissing` write, so re-running over an existing .pugi/ workspace
+ * adds nothing to `created` and the operator sees the "Already
+ * initialized" copy. Default skills install is best-effort: failure
+ * does not throw, the error is appended to the result via stderr so
+ * the slash dispatcher can surface it in the REPL system pane.
+ *
+ * Callers MUST provide `cwd` explicitly; the function does not read
+ * `process.cwd()` so REPL invocations from an arbitrary workspace
+ * cannot accidentally scaffold the binary's install directory.
+ */
+export async function scaffoldPugiWorkspace(input) {
+    const cwd = input.cwd;
+    const log = input.log ?? ((line) => process.stderr.write(line));
     const pugiDir = resolve(cwd, '.pugi');
     const created = [];
     const skipped = [];
@@ -848,11 +907,11 @@ async function init(_args, flags, _session) {
     // alone so re-running `pugi init` after the operator customised one of
     // the defaults does not clobber their edits.
     let defaultSkills = [];
-    if (!flags.noDefaults) {
+    if (!input.noDefaults) {
         try {
             defaultSkills = await installDefaultSkills({
                 workspaceRoot: cwd,
-                log: (line) => process.stderr.write(line),
+                log,
             });
         }
         catch (error) {
@@ -862,29 +921,46 @@ async function init(_args, flags, _session) {
             // the operator sees an unexplained crash. Log the error to stderr
             // and continue — the operator can still install skills manually.
             const message = error instanceof Error ? error.message : String(error);
-            process.stderr.write(`[pugi init] default-skills install failed: ${message}\n`);
+            log(`[pugi init] default-skills install failed: ${message}\n`);
         }
     }
-    const payload = {
+    return {
         status: 'initialized',
         root: cwd,
         created,
         skipped,
         defaultSkills,
+        alreadyInitialized: created.length === 0,
     };
+}
+/**
+ * Standalone `pugi init` CLI entry. Thin wrapper around
+ * `scaffoldPugiWorkspace` that handles flag plumbing + writeOutput
+ * formatting. β1a r1: extracted from the previous inline init so the
+ * REPL's `/init` slash can call `scaffoldPugiWorkspace` directly.
+ */
+async function init(_args, flags, _session) {
+    const result = await scaffoldPugiWorkspace({
+        cwd: process.cwd(),
+        noDefaults: flags.noDefaults,
+    });
     const defaultSkillLines = flags.noDefaults
         ? ['Default skills: skipped (--no-defaults)']
-        : defaultSkills.length === 0
+        : result.defaultSkills.length === 0
             ? ['Default skills: none installed']
             : [
                 'Default skills:',
-                ...defaultSkills.map((entry) => `  ${entry.name.padEnd(18)} ${entry.status}`),
+                ...result.defaultSkills.map((entry) => `  ${entry.name.padEnd(18)} ${entry.status}`),
             ];
-    writeOutput(flags, payload, [
+    writeOutput(flags, result, [
         'Pugi initialized',
-        `Root: ${cwd}`,
-        created.length ? `Created:\n${created.map((path) => `  ${path}`).join('\n')}` : 'Created: none',
-        skipped.length ? `Already present:\n${skipped.map((path) => `  ${path}`).join('\n')}` : 'Already present: none',
+        `Root: ${result.root}`,
+        result.created.length
+            ? `Created:\n${result.created.map((path) => `  ${path}`).join('\n')}`
+            : 'Created: none',
+        result.skipped.length
+            ? `Already present:\n${result.skipped.map((path) => `  ${path}`).join('\n')}`
+            : 'Already present: none',
         ...defaultSkillLines,
     ].join('\n'));
 }
@@ -4362,5 +4438,6 @@ export function packageRoot() {
 export const __test__ = {
     sleep,
     pollDeviceFlowUntilTerminal,
+    sanitizeSemver,
 };
 //# sourceMappingURL=cli.js.map