@pugi/cli 0.1.0-beta.9 → 0.1.0-beta.91

package/dist/core/share/uploader.js

@@ -0,0 +1,267 @@
+/**
+ * Upload paths for `pugi share` ().
+ *
+ * Two targets:
+ *
+ *  - `gist` shells out to `gh gist create` (requires the `gh` CLI in
+ *            PATH AND `gh auth status` ok, OR `GITHUB_TOKEN` env). The
+ *            gist is created with a fixed filename so the URL paths
+ *            stay stable across re-shares.
+ *  - `pugi` POSTs to admin-api `/api/pugi/share`. The endpoint is NOT
+ *            present in admin-api today (2026-05-27 audit) — the
+ *            handler degrades gracefully: it surfaces a clear "endpoint
+ *            not yet wired" message and tells the operator to use
+ *            `--gist` for now. The structured payload is otherwise
+ *            ready for the server-side handler to consume; landing the
+ *            endpoint is a separate sprint.
+ *
+ * The two paths share one decision shape (`UploadResult`) so the
+ * command handler renders identical telemetry regardless of which target
+ * was chosen.
+ *
+ * Why we shell out for gist instead of using octokit: octokit would add
+ * a transitive HTTP client + ~200 KB to the npm package surface for a
+ * single feature. `gh gist create` is the operator-friendly form
+ * (already auth'd, public URL on stdout, attribution in the gist
+ * metadata) and degrades cleanly when `gh` is absent.
+ */
+import { spawn } from 'node:child_process';
+/**
+ * Default execa shim. Spawns the binary with `args`, pipes `input` into
+ * stdin if provided, captures stdout + stderr in memory. The CLI ships
+ * with `execa` already pulled for other paths; we use the lighter
+ * `child_process.spawn` here so the share module stays import-clean.
+ */
+export const defaultExecaLike = (file, args, options) => {
+    return new Promise((resolveProm, rejectProm) => {
+        const child = spawn(file, [...args], { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString('utf8');
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString('utf8');
+        });
+        child.on('error', (err) => {
+            // ENOENT (binary missing) lands here; the caller maps it.
+            rejectProm(err);
+        });
+        child.on('close', (code) => {
+            resolveProm({ exitCode: code ?? 0, stdout, stderr });
+        });
+        if (options?.input) {
+            child.stdin.write(options.input);
+        }
+        child.stdin.end();
+    });
+};
+/**
+ * Top-level upload dispatch. The handler picks the right path and
+ * surfaces a uniform result envelope.
+ */
+export async function uploadShare(req) {
+    if (req.target === 'gist') {
+        return uploadGist(req);
+    }
+    return uploadPugi(req);
+}
+/**
+ * Gist upload. Two-step: probe `gh --version` (fast, costs nothing) to
+ * detect a missing binary cleanly, then run `gh gist create`. We pipe
+ * the markdown into stdin to avoid temp files + the OS-level argv
+ * length cap.
+ */
+async function uploadGist(req) {
+    const exec = req.execaLike ?? defaultExecaLike;
+    const description = req.description ?? `Pugi session ${req.sessionId}`;
+    try {
+        // Probe step. `gh --version` returns 0 quickly and surfaces a
+        // distinctive "command not found" via ENOENT on the reject path.
+        const probe = await exec('gh', ['--version']);
+        if (probe.exitCode !== 0) {
+            return {
+                ok: false,
+                target: 'gist',
+                reason: 'gh_not_installed',
+                message: 'gh CLI not available. Install from https://cli.github.com or use --pugi instead.',
+            };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            target: 'gist',
+            reason: 'gh_not_installed',
+            message: 'gh CLI not available. Install from https://cli.github.com or use --pugi instead.',
+        };
+    }
+    // Create the gist. `gh` reads stdin when `-` is the filename arg, which
+    // works with our `--filename` override. The `--public` flag is
+    // intentionally omitted — gists default to secret (unlisted URL), which
+    // is the right default for a session transcript. Operators who want a
+    // public gist can run `gh gist edit --add-public <id>` after the fact.
+    const createArgs = [
+        'gist',
+        'create',
+        '--filename',
+        'pugi-session.md',
+        '--desc',
+        description,
+        '-',
+    ];
+    try {
+        const result = await exec('gh', createArgs, { input: req.markdown });
+        if (result.exitCode !== 0) {
+            // Auth failure is the common case. `gh` prints "gh auth login" to
+            // stderr; we tag it specifically so the gate banner can hint.
+            const looksLikeAuth = /auth/i.test(result.stderr) || /authenticated/i.test(result.stderr);
+            return {
+                ok: false,
+                target: 'gist',
+                reason: looksLikeAuth ? 'gh_unauthenticated' : 'gh_failed',
+                message: looksLikeAuth
+                    ? 'gh is installed but not authenticated. Run `gh auth login` first.'
+                    : `gh gist create exited ${result.exitCode}: ${result.stderr.trim().slice(0, 200)}`,
+            };
+        }
+        // gh prints the URL on stdout. Trim newline + any leading whitespace.
+        const url = result.stdout.trim().split('\n').pop() ?? '';
+        if (!/^https?:\/\//.test(url)) {
+            return {
+                ok: false,
+                target: 'gist',
+                reason: 'gh_failed',
+                message: `gh did not return a URL (stdout: "${result.stdout.trim().slice(0, 200)}")`,
+            };
+        }
+        const remoteId = url.split('/').pop() ?? undefined;
+        return remoteId !== undefined
+            ? { ok: true, target: 'gist', url, remoteId }
+            : { ok: true, target: 'gist', url };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            target: 'gist',
+            reason: 'gh_failed',
+            message: `gh gist create threw: ${message}`,
+        };
+    }
+}
+/**
+ * Pugi.io upload. POSTs the transcript to admin-api `/api/pugi/share`.
+ * The endpoint is NOT yet wired (audit); when it returns 404
+ * we surface a friendly hint instead of a stack trace. When the operator
+ * is signed-out we surface `pugi_auth_missing` so the gate banner can
+ * point at `pugi login`.
+ *
+ * The wire payload is intentionally minimal so a future server-side
+ * implementation has a stable contract to build against:
+ *
+ *  { sessionId, markdown, description?, cliVersion? }
+ *
+ * Response (when wired):
+ *
+ *  200 { ok: true, url, id }    URL is the pugi.io/share/<id> public link.
+ *  404 / 501                    endpoint not yet implemented — graceful skip.
+ *  401                          auth missing/expired — operator runs `pugi login`.
+ */
+async function uploadPugi(req) {
+    const fetchFn = req.fetchLike ?? globalThis.fetch;
+    if (typeof fetchFn !== 'function') {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_network_error',
+            message: 'No fetch implementation available (Node >=18 expected).',
+        };
+    }
+    if (!req.apiUrl) {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_auth_missing',
+            message: 'pugi.io share requires a signed-in session. Run `pugi login` and retry.',
+        };
+    }
+    const url = `${req.apiUrl.replace(/\/+$/u, '')}/api/pugi/share`;
+    const headers = {
+        'content-type': 'application/json',
+        accept: 'application/json',
+    };
+    if (req.apiToken) {
+        headers.authorization = `Bearer ${req.apiToken}`;
+    }
+    const body = JSON.stringify({
+        sessionId: req.sessionId,
+        markdown: req.markdown,
+        description: req.description ?? `Pugi session ${req.sessionId}`,
+    });
+    let res;
+    try {
+        res = await fetchFn(url, { method: 'POST', headers, body });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_network_error',
+            message: `pugi.io upload failed: ${message}`,
+        };
+    }
+    // 404 / 501 → endpoint not yet wired. Surface a friendly hint instead
+    // of dumping the response body.
+    if (res.status === 404 || res.status === 501) {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_endpoint_unimplemented',
+            message: 'pugi.io /api/pugi/share is not yet wired in admin-api. ' +
+                'Use `--gist` for now; the pugi.io upload lands in a follow-up sprint.',
+        };
+    }
+    if (res.status === 401 || res.status === 403) {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_auth_missing',
+            message: 'pugi.io rejected the credentials. Run `pugi login` and retry.',
+        };
+    }
+    if (!res.ok) {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_network_error',
+            message: `pugi.io upload returned ${res.status} ${res.statusText}.`,
+        };
+    }
+    let payload;
+    try {
+        payload = (await res.json());
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_network_error',
+            message: `pugi.io upload returned non-JSON: ${message}`,
+        };
+    }
+    if (!payload.ok || !payload.url) {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_network_error',
+            message: 'pugi.io upload succeeded but the response was missing { ok, url }.',
+        };
+    }
+    return payload.id !== undefined
+        ? { ok: true, target: 'pugi', url: payload.url, remoteId: payload.id }
+        : { ok: true, target: 'pugi', url: payload.url };
+}
+//# sourceMappingURL=uploader.js.map

package/dist/core/skills/defaults.js

@@ -25,30 +25,30 @@ export const DEFAULT_SKILLS = [
             '## Language split',
             '',
             '- Code, comments, commit messages, PR titles + bodies, technical docs,',
-            "  generated tests, log strings: **English**. Do not switch mid-line.",
+            " generated tests, log strings: **English**. Do not switch mid-line.",
             '- Operator-facing chat replies follow the workspace `settings.json`',
-            '  `workflow.chatLang` (defaults to English when unset).',
+            ' `workflow.chatLang` (defaults to English when unset).',
             '',
             '## No AI attribution',
             '',
             '- Never add `Co-Authored-By: Claude` (or Codex, Gemini, Cursor) trailers',
-            '  to commits or PR bodies.',
-            '- Never write "Generated with Claude Code", "Made with AI", or any',
-            '  variant in PR descriptions, README content, or release notes.',
+            ' to commits or PR bodies.',
+            '- Never write "Generated with the upstream tool", "Made with AI", or any',
+            ' variant in PR descriptions, README content, or release notes.',
             '- Pugi itself is the byline; the underlying model is implementation',
-            '  detail and stays out of customer-visible text.',
+            ' detail and stays out of customer-visible text.',
             '',
             '## No emoji decoration',
             '',
             '- Skip decorative emoji in commit messages, PR bodies, code comments,',
-            '  log lines, and chat replies.',
+            ' log lines, and chat replies.',
             '- Functional unicode that carries meaning (math symbols, currency,',
-            '  language scripts) is fine.',
+            ' language scripts) is fine.',
             '',
             '## No em dashes',
             '',
             '- Prefer regular hyphens or restructure the sentence. The em dash',
-            '  character reads as ChatGPT-flavoured and we keep our voice distinct.',
+            ' character reads as ChatGPT-flavoured and we keep our voice distinct.',
             '',
             '## Verb grammar',
             '',
@@ -76,15 +76,15 @@ export const DEFAULT_SKILLS = [
             '## Rule',
             '',
             '1. Before any tool call that writes a URL (`write`, `edit`, `patch`),',
-            '   enumerate the URLs the diff introduces.',
+            '  enumerate the URLs the diff introduces.',
             '2. For each URL whose host is reachable from the workspace, issue a',
-            '   `HEAD` request (or `GET` when the host blocks `HEAD`).',
+            '  `HEAD` request (or `GET` when the host blocks `HEAD`).',
             '3. Treat the URL as **valid** only when the response is 2xx, 3xx, or',
-            '   a documented 401/403 (auth-gated endpoint we expect).',
+            '  a documented 401/403 (auth-gated endpoint we expect).',
             '4. Treat the URL as **invalid** on `ENOTFOUND`, `ECONNREFUSED`,',
-            '   timeout, or 4xx/5xx other than the documented auth codes. In that',
-            '   case do not write the URL; ask the operator for the correct one or',
-            '   pull it from `.pugi/settings.json` / `.env`.',
+            '  timeout, or 4xx/5xx other than the documented auth codes. In that',
+            '  case do not write the URL; ask the operator for the correct one or',
+            '  pull it from `.pugi/settings.json` / `.env`.',
             '',
             '## Why this matters',
             '',
@@ -97,11 +97,11 @@ export const DEFAULT_SKILLS = [
             '## Skip cases',
             '',
             '- Localhost URLs (`http://127.0.0.1:*`, `http://localhost:*`): skip',
-            '  the probe; verify visually that the port matches the workspace dev',
-            '  server config instead.',
+            ' the probe; verify visually that the port matches the workspace dev',
+            ' server config instead.',
             '- Example URLs in comments explicitly marked `// example:` or',
-            '  `# example:`: skip the probe; the operator has flagged the URL as',
-            '  illustrative.',
+            ' `# example:`: skip the probe; the operator has flagged the URL as',
+            ' illustrative.',
             '',
         ].join('\n'),
     },
@@ -118,17 +118,17 @@ export const DEFAULT_SKILLS = [
             'Whenever a `build` task renames a package or its binary, the README',
             'must move with it. Stale install snippets are the most common Pugi',
             'regression: the binary ships as `@pugi/cli` but the README still',
-            'tells the operator to `npm i -g @codeforge/cli`, and the install',
+            'tells the operator to `npm i -g @pugi/cli`, and the install',
             "fails before they ever see `pugi --version`.",
             '',
             '## Rule',
             '',
             'Whenever a diff touches `package.json` and changes any of:',
             '',
-            '  - `name`',
-            '  - `bin`',
-            '  - `scripts.start` / `scripts.dev`',
-            '  - top-level `homepage` / `repository.url`',
+            ' - `name`',
+            ' - `bin`',
+            ' - `scripts.start` / `scripts.dev`',
+            ' - top-level `homepage` / `repository.url`',
             '',
             'then the same diff MUST also update the corresponding sections of the',
             "package's `README.md` (and, when the package has a docs landing page,",
@@ -152,7 +152,7 @@ export const DEFAULT_SKILLS = [
             '## Idempotence',
             '',
             'This rule applies to every package in the workspace, not just the',
-            "first one the operator mentions. A monorepo-wide rename (`@codeforge/*`",
+            "first one the operator mentions. A monorepo-wide rename (`@pugi/*`",
             "to `@pugi/*`) has to sync every README, not just the customer-facing",
             'CLI README.',
             '',
@@ -168,7 +168,7 @@ export const DEFAULT_SKILLS = [
         body: [
             '# Zoom out',
             '',
-            '**Source:** [mattpocock/skills](https://github.com/mattpocock/skills/blob/main/skills/engineering/zoom-out/SKILL.md) - MIT licensed, authored by Matt Pocock. Ported verbatim into the Pugi bundle on 2026-05-26.',
+            '**Source:** [mattpocock/skills](https://github.com/mattpocock/skills/blob/main/skills/engineering/zoom-out/SKILL.md) - MIT licensed, authored by Matt Pocock. Ported verbatim into the Pugi bundle on.',
             '',
             'I do not know this area of code well. Go up a layer of abstraction.',
             'Give me a map of all the relevant modules and callers, using the',
@@ -186,7 +186,7 @@ export const DEFAULT_SKILLS = [
         body: [
             '# Diagnose',
             '',
-            '**Source:** [mattpocock/skills](https://github.com/mattpocock/skills/blob/main/skills/engineering/diagnose/SKILL.md) - MIT licensed, authored by Matt Pocock. Ported into the Pugi bundle on 2026-05-26 with minor de-namespacing (cross-skill links rewritten, project-glossary references generalised).',
+            '**Source:** [mattpocock/skills](https://github.com/mattpocock/skills/blob/main/skills/engineering/diagnose/SKILL.md) - MIT licensed, authored by Matt Pocock. Ported into the Pugi bundle on with minor de-namespacing (cross-skill links rewritten, project-glossary references generalised).',
             '',
             'A discipline for hard bugs. Skip phases only when explicitly justified.',
             '',
@@ -349,7 +349,7 @@ export const DEFAULT_SKILLS = [
         body: [
             '# Grill me',
             '',
-            '**Source:** [mattpocock/skills](https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md) - MIT licensed, authored by Matt Pocock. Ported verbatim into the Pugi bundle on 2026-05-26 (terminology swap: "user" -> "operator" to match Pugi vocabulary).',
+            '**Source:** [mattpocock/skills](https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md) - MIT licensed, authored by Matt Pocock. Ported verbatim into the Pugi bundle on (terminology swap: "user" -> "operator" to match Pugi vocabulary).',
             '',
             'Interview the operator relentlessly about every aspect of this plan',
             'until we reach a shared understanding. Walk down each branch of the',
@@ -377,8 +377,8 @@ function renderSkillMarkdown(spec) {
         `name: ${spec.name}`,
         `description: ${spec.description}`,
         'metadata:',
-        '  type: skill',
-        `  version: ${spec.version}`,
+        ' type: skill',
+        ` version: ${spec.version}`,
         '---',
         '',
     ].join('\n');

package/dist/core/skills/loader.js

@@ -6,12 +6,12 @@ const FRONTMATTER_DELIM = '---';
  * Parse a markdown file with YAML frontmatter into a structured form.
  *
  * Throws when:
- *   - no frontmatter delimiter pair is present
- *   - frontmatter does not parse as the minimal YAML grammar
- *   - required keys `name`, `description`, `metadata.type` are missing
+ *  - no frontmatter delimiter pair is present
+ *  - frontmatter does not parse as the minimal YAML grammar
+ *  - required keys `name`, `description`, `metadata.type` are missing
  *
  * Frontmatter `tools` accepts either flow array (`[a, b, c]`) or block
- * array (newline + `  - a` lines). Strings are unquoted, single, or
+ * array (newline + ` - a` lines). Strings are unquoted, single, or
  * double quoted. Multi-line scalar values are NOT supported (no `>` or
  * `|` folding) — Skills do not need them.
  */
@@ -146,7 +146,7 @@ function parseBlockObject(lines, from) {
                     consumed += arr.consumed + 1;
                     continue;
                 }
-                // Deeper objects are out of scope for α7.0 — keep frontmatter
+                // Deeper objects are out of scope for — keep frontmatter
                 // shape predictable. Throw with a clear pointer.
                 throw new Error(`SKILL_PARSE: nested objects deeper than 1 level are not supported (key "${key}")`);
             }
@@ -212,12 +212,12 @@ function validateFrontmatter(raw) {
     // Two frontmatter dialects coexist in the wild:
     //
     // 1. Pugi-native — explicit `metadata: { type: skill|agent, ... }`.
-    //    Future Pugi-published skills + agents use this so the kind is
-    //    self-declared at parse time.
+    //   Future Pugi-published skills + agents use this so the kind is
+    //   self-declared at parse time.
     //
     // 2. Anthropic Skills — flat top-level keys, no `metadata` block, no
-    //    `type` field. Every file inside `github.com/anthropics/skills`
-    //    follows this shape (e.g. `algorithmic-art`, `pdf`, `pptx`).
+    //   `type` field. Every file inside `github.com/anthropics/skills`
+    //   follows this shape (e.g. `algorithmic-art`, `pdf`, `pptx`).
     //
     // We accept both. When `metadata` is absent we synthesize one with
     // `type` defaulted to `skill` — the on-disk layout (`SKILL.md` in a
@@ -267,7 +267,7 @@ function validateFrontmatter(raw) {
         if (node.kind === 'scalar') {
             fm[key] = node.value;
             // Anthropic Skills flat dialect — also surface select top-level
-            // keys inside metadata so downstream consumers (Mira system
+            // keys inside metadata so downstream consumers (Pugi system
             // prompt builder, `skills list` table) have one consistent path.
             if (key === 'license' || key === 'version' || key === 'model' || key === 'allowed-tools') {
                 const metaKey = key === 'allowed-tools' ? 'tools' : key;
@@ -317,20 +317,20 @@ function expectScalar(obj, key) {
 /* ----------------------------- Slug validation ----------------------------- */
 /**
  * Slug grammar for skill + agent names. Allowed characters:
- *   - lowercase ASCII letters, digits, hyphen, underscore, dot
- *   - 1–64 characters total, must START with [a-z0-9]
+ *  - lowercase ASCII letters, digits, hyphen, underscore, dot
+ *  - 1–64 characters total, must START with [a-z0-9]
  *
  * Anything outside this grammar is rejected BEFORE the name reaches a
  * `path.join` call. Attacker payloads we close here:
- *   - `../../foo`            (path traversal segment)
- *   - `/etc/passwd`          (absolute path)
- *   - `..\\..\\foo`          (Windows traversal)
- *   - `\0name`               (null-byte truncation)
- *   - `name\\with\\backslash` (Windows separator)
- *   - `..` or `.`            (dot-only segments)
- *   - empty string           (matches existing skill on globbed list)
- *   - 65+ char strings       (DoS via huge directory names)
- *   - uppercase / unicode    (collision on case-insensitive filesystems)
+ *  - `../../foo`           (path traversal segment)
+ *  - `/etc/passwd`         (absolute path)
+ *  - `..\\..\\foo`         (Windows traversal)
+ *  - `\0name`              (null-byte truncation)
+ *  - `name\\with\\backslash` (Windows separator)
+ *  - `..` or `.`           (dot-only segments)
+ *  - empty string          (matches existing skill on globbed list)
+ *  - 65+ char strings      (DoS via huge directory names)
+ *  - uppercase / unicode   (collision on case-insensitive filesystems)
  *
  * The CLI commands also accept `--as <slug>` so this guard runs on the
  * operator-supplied override AND on the parsed frontmatter `name`. Both
@@ -415,7 +415,7 @@ function loadSkill(skillDir, scope) {
  * responsible for trust-prompting + hashing before this is invoked.
  *
  * Refuses to install when the payload does not contain a `SKILL.md` at
- * its root: that file is the contract every consumer (Mira system
+ * its root: that file is the contract every consumer (Pugi system
  * prompt, `skills list`, `skills info`) reads from.
  */
 export function installSkill(input) {

package/dist/core/skills/sources.js

@@ -12,29 +12,29 @@ import { validateHostnameForFetch } from '../../tools/web-fetch.js';
  *
  * Supported source schemes:
  *
- *   1. `gh:owner/repo[/subdir][@ref]`
- *      → `gh:anthropics/skills/python-coding-standards@main`
- *      Fetches the GitHub tarball via the public codeload endpoint,
- *      extracts the requested subtree.
+ *  1. `gh:owner/repo[/subdir][@ref]`
+ *     → `gh:anthropics/skills/python-coding-standards@main`
+ *     Fetches the GitHub tarball via the public codeload endpoint,
+ *     extracts the requested subtree.
  *
- *   2. `https://github.com/<owner>/<repo>/tree/<ref>/<subdir>` (or `/blob/`)
- *      Normalised to the gh: form above.
+ *  2. `https://github.com/<owner>/<repo>/tree/<ref>/<subdir>` (or `/blob/`)
+ *     Normalised to the gh: form above.
  *
- *   3. `anthropic:<slug>` — convenience alias for
- *      `gh:anthropics/skills/<slug>@main`. Hard-coded base; the only
- *      reason this exists is so operators can copy a slug from the
- *      Anthropic docs without remembering the org name.
+ *  3. `anthropic:<slug>` — convenience alias for
+ *     `gh:anthropics/skills/<slug>@main`. Hard-coded base; the only
+ *     reason this exists is so operators can copy a slug from the
+ *     Anthropic docs without remembering the org name.
  *
- *   4. `npm:<package>` — fetches a tarball from the npm registry,
- *      extracts, looks for `SKILL.md` at the package root.
+ *  4. `npm:<package>` — fetches a tarball from the npm registry,
+ *     extracts, looks for `SKILL.md` at the package root.
  *
- *   5. Local path — `./relative` or `/abs/path`. Copied to tmp so the
- *      caller can mutate the original without affecting install.
+ *  5. Local path — `./relative` or `/abs/path`. Copied to tmp so the
+ *     caller can mutate the original without affecting install.
  *
- *   6. Catalog name — bare slug, queried against
- *      `https://catalog.pugi.dev/api/skills/<name>`. Returns a 404 →
- *      we surface a hint pointing at the `gh:anthropics/skills/<name>`
- *      form rather than crashing.
+ *  6. Catalog name — bare slug, queried against
+ *     `https://catalog.pugi.dev/api/skills/<name>`. Returns a 404 →
+ *     we surface a hint pointing at the `gh:anthropics/skills/<name>`
+ *     form rather than crashing.
  *
  * Every resolver writes the payload into a fresh temp dir under
  * `/tmp/pugi-skill-XXXXXX/` (caller cleans up after install completes).
@@ -58,7 +58,7 @@ export async function fetchSource(source) {
             throw new Error(`SOURCE_PARSE: anthropic: source needs a bare slug (got "${source}"). Example: anthropic:algorithmic-art`);
         }
         // Real layout is `anthropics/skills` repo → `skills/<slug>/SKILL.md`.
-        // Verified 2026-05-25 against the live repo tarball.
+        // Verified against the live repo tarball.
         return fetchGitHub(`${ANTHROPIC_REPO}/skills/${slug}@main`.slice(3));
     }
     if (source.startsWith('npm:')) {
@@ -113,7 +113,7 @@ async function fetchGitHub(raw) {
     const spec = parseGithubSpec(raw);
     // Use codeload.github.com — the public tarball endpoint requires no
     // auth for public repos and returns a single .tar.gz of the requested
-    // ref's tree. Private repos are out of scope for α7.0.
+    // ref's tree. Private repos are out of scope for .
     const tarUrl = `https://codeload.github.com/${spec.owner}/${spec.repo}/tar.gz/${spec.ref}`;
     const tmpRoot = mkdtempSync(join(tmpdir(), 'pugi-skill-gh-'));
     const tarPath = join(tmpRoot, 'payload.tar.gz');
@@ -268,9 +268,9 @@ async function requestFollow(url) {
     // future: webhook delivery). Drift between two copies of that block
     // list would be a real footgun — the SSRF cheat-sheet covers ~10
     // ranges and missing one (e.g. SIIT/NAT64) is exactly the class of
-    // bug Codex caught in PR #349.
+    // bug Codex caught in PR.
     // Initial scheme — locked for entire redirect chain. Codex P2 review
-    // (PR #362 v2): an HTTPS source that 302s к public http:// URL would
+    // (PR v2): an HTTPS source that 302s к public http:// URL would
     // otherwise be fetched cleartext, MITM tampers payload. Stay TLS.
     const initialScheme = new URL(currentUrl).protocol;
     await guardOutboundUrl(currentUrl, 'initial request', initialScheme);
@@ -321,7 +321,7 @@ async function guardOutboundUrl(rawUrl, label, initialScheme) {
     if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
         throw new Error(`SOURCE_SSRF: ${label} uses unsupported scheme ${parsed.protocol} (only http/https).`);
     }
-    // Codex P2 PR #362 v2: HTTPS source MUST NOT downgrade к HTTP across
+    // Codex P2 PR v2: HTTPS source MUST NOT downgrade к HTTP across
     // redirect chain — would let MITM tamper с payload after the initial
     // TLS hop. Once we started TLS, stay TLS.
     if (initialScheme === 'https:' && parsed.protocol === 'http:') {
@@ -405,20 +405,20 @@ async function extractTarball(tarPath, destDir) {
         // violations and throw AFTER extraction completes (see below).
         filter: (path, entry) => {
             // 1. Block any symlink or hardlink — these are the tar-slip
-            //    vectors. A symlink to ../../home/user/.ssh + a follow-up
-            //    write to that symlink would exfil secrets.
+            //   vectors. A symlink to ../../home/user/.ssh + a follow-up
+            //   write to that symlink would exfil secrets.
             if (entry.type === 'SymbolicLink' || entry.type === 'Link') {
                 violations.push(`SOURCE_TAR_SYMLINK: tarball contains ${entry.type} entry (${path} → ${entry.linkpath ?? '?'}). Refusing extraction.`);
                 return false;
             }
             // 2. Block absolute paths — `tar` strips the leading "/" in
-            //    permissive mode and writes anyway. We refuse such entries.
+            //   permissive mode and writes anyway. We refuse such entries.
             if (path.startsWith('/')) {
                 violations.push(`SOURCE_TAR_ABSOLUTE: tarball entry has absolute path: ${path}`);
                 return false;
             }
             // 3. Block parent-traversal segments. `..` as a path segment
-            //    cannot be present in any legitimate skill/agent payload.
+            //   cannot be present in any legitimate skill/agent payload.
             const segments = path.split(/[\\/]+/);
             if (segments.includes('..')) {
                 violations.push(`SOURCE_TAR_TRAVERSAL: tarball entry has parent-traversal segment: ${path}`);