portable-agent-layer 0.62.0 → 0.62.2

package/assets/skills/consulting-report/SKILL.md

@@ -78,7 +78,7 @@ Wraps `bun run dev` in the report directory. Open the URL printed by Next, edit
 ### 4. Render the PDF
 
 ```bash
-node --experimental-strip-types ~/.pal/skills/consulting-report/tools/generate-pdf.ts <report-dir>
+node ~/.pal/skills/consulting-report/tools/generate-pdf.mjs <report-dir>
 ```
 
 Runs `next build` (which produces a static export at `out/`), then Playwright loads it via a tiny in-process HTTP server and prints the PDF with page-numbered header/footer. Output:
@@ -140,14 +140,14 @@ Run with **Node**, not Bun — Playwright's `chromium.launch()` hangs under Bun
 ## Demo
 
 ```bash
-node --experimental-strip-types ~/.pal/skills/consulting-report/tools/generate-pdf.ts ~/.pal/skills/consulting-report/demo
+node ~/.pal/skills/consulting-report/tools/generate-pdf.mjs ~/.pal/skills/consulting-report/demo
 ```
 
 Renders the bundled Acme Industries example end-to-end. Inspect the resulting PDF to see the full layout before authoring your own.
 
 ## Important
 
-- Run on Node ≥ 22.6 (Playwright + `--experimental-strip-types`)
+- Run on Node (Playwright); the tool ships as a compiled `.mjs` so no `--experimental-strip-types` is needed
 - Bundled fonts come from Google Fonts via `next/font/google` — no licensing surface, no CDN at runtime, glyphs embedded at build time
 - Reports are disposable artifacts of `lib/report-data.ts` + `app/page.tsx`; commit the source, not the PDF
 - The scaffolder runs `bun install` inside the target by default — pass `--no-install` to skip

package/assets/skills/consulting-report/tools/generate-pdf.mjs

@@ -0,0 +1,226 @@
+import { spawnSync } from "node:child_process";
+import { createReadStream, constants as fsConstants, realpathSync } from "node:fs";
+import { access, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { extname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { PDFDocument } from "pdf-lib";
+import { chromium } from "playwright";
+const COLOR = {
+  navy: "#0f172a",
+  blue: "#1d4ed8",
+  red: "#dc2626"
+};
+async function exists(p) {
+  try {
+    await access(p, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function escapeHtml(s) {
+  return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+async function logoDataUri(outDir, publicPath) {
+  if (!publicPath)
+    return null;
+  const filePath = join(outDir, publicPath);
+  if (!await exists(filePath))
+    return null;
+  const buf = await readFile(filePath);
+  const ext = extname(filePath).toLowerCase();
+  let mime = "image/jpeg";
+  if (ext === ".svg") {
+    mime = "image/svg+xml";
+  } else if (ext === ".png") {
+    mime = "image/png";
+  }
+  return `data:${mime};base64,${buf.toString("base64")}`;
+}
+async function loadMeta(reportDir) {
+  const dataPath = join(reportDir, "lib", "report-data.ts");
+  if (!await exists(dataPath)) {
+    throw new Error(`lib/report-data.ts not found at ${dataPath}`);
+  }
+  const mod = await import(pathToFileURL(dataPath).href);
+  if (!mod.reportData) {
+    throw new Error(`lib/report-data.ts must export a named 'reportData' constant`);
+  }
+  return mod.reportData;
+}
+function buildNext(reportDir) {
+  const result = spawnSync("bun", ["run", "build"], {
+    cwd: reportDir,
+    stdio: "inherit",
+    shell: true
+  });
+  if (result.status !== 0) {
+    throw new Error(`next build failed (exit ${result.status})`);
+  }
+}
+function serveStatic(rootDir) {
+  const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon"
+  };
+  return new Promise((res) => {
+    const server = createServer((req, response) => {
+      const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);
+      let filePath = join(rootDir, urlPath === "/" ? "/index.html" : urlPath);
+      if (filePath.endsWith("/"))
+        filePath = join(filePath, "index.html");
+      const ext = extname(filePath).toLowerCase();
+      response.setHeader("Content-Type", MIME[ext] ?? "application/octet-stream");
+      const stream = createReadStream(filePath);
+      stream.on("error", () => {
+        response.statusCode = 404;
+        response.end();
+      });
+      stream.pipe(response);
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      res({ server, url: `http://127.0.0.1:${port}/` });
+    });
+  });
+}
+async function renderPdf(htmlPath, pdfPath, meta) {
+  const outDir = resolve(htmlPath, "..");
+  const { server, url } = await serveStatic(outDir);
+  const browser = await chromium.launch();
+  try {
+    const page = await browser.newPage();
+    await page.goto(url, { waitUntil: "networkidle" });
+    await page.evaluate(async () => {
+      await document.fonts?.ready;
+      const imgs = Array.from(document.querySelectorAll("img"));
+      await Promise.all(imgs.map((img) => img.complete ? Promise.resolve() : new Promise((res) => {
+        img.onload = () => res(null);
+        img.onerror = () => res(null);
+        setTimeout(() => res(null), 5000);
+      })));
+    });
+    const [clientUri, consultancyUri] = await Promise.all([
+      logoDataUri(outDir, meta.clientLogoSrc),
+      logoDataUri(outDir, meta.consultancyLogoSrc)
+    ]);
+    const clientSlot = clientUri ? `<img src="${clientUri}" style="height:18px; width:auto; object-fit:contain; display:block;">` : `<span style="font-weight:600; color:${COLOR.navy}; letter-spacing:0.05em;">${escapeHtml(meta.clientName.toUpperCase())}</span>`;
+    const consultancySlot = consultancyUri ? `<img src="${consultancyUri}" style="height:14px; width:auto; object-fit:contain; display:block;">` : `<span style="color:${COLOR.navy};">${escapeHtml(meta.consultancyName)}</span>`;
+    const header = `
+<div style="width:100%; font-family:Inter,'Helvetica Neue',Arial,sans-serif; font-size:7.5pt; padding:0 0.7in; display:flex; justify-content:space-between; align-items:center;">
+  ${clientSlot}
+  <span style="color:#94a3b8;">${escapeHtml(meta.reportTitle)}</span>
+</div>`;
+    const footer = `
+<div style="width:100%; font-family:Inter,'Helvetica Neue',Arial,sans-serif; font-size:7.5pt; padding:0 0.7in; display:flex; justify-content:space-between; align-items:center;">
+  ${consultancySlot}
+  <span style="color:${COLOR.navy};"><span class="pageNumber"></span></span>
+</div>`;
+    const margin = { top: "0.7in", right: "0.7in", bottom: "0.7in", left: "0.7in" };
+    const tmpCover = `${pdfPath}.cover.tmp.pdf`;
+    const tmpBody = `${pdfPath}.body.tmp.pdf`;
+    await Promise.all([
+      page.pdf({
+        path: tmpCover,
+        format: "A4",
+        pageRanges: "1",
+        printBackground: true,
+        displayHeaderFooter: false,
+        margin: { top: "0", right: "0", bottom: "0", left: "0" },
+        preferCSSPageSize: false
+      }),
+      page.pdf({
+        path: tmpBody,
+        format: "A4",
+        pageRanges: "2-",
+        printBackground: true,
+        displayHeaderFooter: true,
+        headerTemplate: header,
+        footerTemplate: footer,
+        margin,
+        preferCSSPageSize: false
+      })
+    ]);
+    const [coverBytes, bodyBytes] = await Promise.all([
+      readFile(tmpCover),
+      readFile(tmpBody)
+    ]);
+    const [coverDoc, bodyDoc] = await Promise.all([
+      PDFDocument.load(coverBytes),
+      PDFDocument.load(bodyBytes)
+    ]);
+    const [coverPage] = await bodyDoc.copyPages(coverDoc, [0]);
+    bodyDoc.insertPage(0, coverPage);
+    await writeFile(pdfPath, await bodyDoc.save());
+    await Promise.all([unlink(tmpCover), unlink(tmpBody)]);
+  } finally {
+    await browser.close();
+    server.close();
+  }
+}
+async function generate(opts) {
+  const dir = resolve(opts.reportDir);
+  if (!await exists(join(dir, "package.json"))) {
+    throw new Error(`not a scaffolded report (missing package.json): ${dir}`);
+  }
+  if (!opts.skipBuild) {
+    buildNext(dir);
+  }
+  const htmlPath = join(dir, "out", "index.html");
+  if (!await exists(htmlPath)) {
+    throw new Error(`static export missing: ${htmlPath} — run without --skip-build`);
+  }
+  const meta = await loadMeta(dir);
+  const slug = `${slugify(meta.clientName)}-${slugify(meta.reportTitle)}-${slugify(new Date().toISOString().slice(0, 10))}`;
+  const pdfPath = opts.pdfOut ? resolve(opts.pdfOut) : join(dir, `${slug}.pdf`);
+  await renderPdf(htmlPath, pdfPath, meta);
+  return { htmlPath, pdfPath };
+}
+function parseArgs(argv) {
+  if (argv.length === 0) {
+    throw new Error("usage: generate-pdf.ts <report-dir> [--pdf <out>] [--skip-build]");
+  }
+  const opts = { reportDir: argv[0] };
+  for (let i = 1;i < argv.length; i++) {
+    if (argv[i] === "--pdf")
+      opts.pdfOut = argv[++i];
+    else if (argv[i] === "--html")
+      opts.htmlOut = argv[++i];
+    else if (argv[i] === "--skip-build")
+      opts.skipBuild = true;
+  }
+  return opts;
+}
+async function run(argv = process.argv.slice(2)) {
+  const opts = parseArgs(argv);
+  const { htmlPath, pdfPath } = await generate(opts);
+  const [htmlStat, pdfStat] = await Promise.all([stat(htmlPath), stat(pdfPath)]);
+  console.log(`HTML: ${htmlPath} (${(htmlStat.size / 1024).toFixed(1)} KB)`);
+  console.log(`PDF:  ${pdfPath} (${(pdfStat.size / 1024).toFixed(1)} KB)`);
+}
+function realResolve(p) {
+  try {
+    return realpathSync(resolve(p));
+  } catch {
+    return resolve(p);
+  }
+}
+const isMain = process.argv[1] && realResolve(process.argv[1]) === realResolve(new URL(import.meta.url).pathname);
+if (isMain) {
+  await run();
+}

package/assets/skills/consulting-report/tools/generate-pdf.ts

@@ -8,8 +8,11 @@
 // Windows because it uses --remote-debugging-pipe over stdio and Bun's Windows
 // child-process pipe handling doesn't complete the CDP handshake.
 //
+// pal-build:mjs — ships as a compiled generate-pdf.mjs sibling (scripts/build-skill-tools.ts)
+// and is invoked as that .mjs: a .ts under node_modules can't be type-stripped by Node.
+//
 // Usage:
-//   node --experimental-strip-types ~/.pal/skills/consulting-report/tools/generate-pdf.ts <report-dir> [--pdf <out>] [--html <out>] [--skip-build]
+//   node ~/.pal/skills/consulting-report/tools/generate-pdf.mjs <report-dir> [--pdf <out>] [--html <out>] [--skip-build]
 
 import { spawnSync } from "node:child_process";
 import { createReadStream, constants as fsConstants, realpathSync } from "node:fs";

package/assets/skills/consulting-report/tools/scaffold.ts

@@ -100,7 +100,7 @@ async function run(argv: string[] = process.argv.slice(2)): Promise<void> {
   console.log(`  2. Edit lib/report-data.ts (metadata) and app/page.tsx (layout)`);
   console.log(`  3. Live preview:    bun run dev`);
   console.log(
-    `  4. Generate PDF:    node --experimental-strip-types ~/.pal/skills/consulting-report/tools/generate-pdf.ts ${opts.targetDir}`
+    `  4. Generate PDF:    node ~/.pal/skills/consulting-report/tools/generate-pdf.mjs ${opts.targetDir}`
   );
 }
 

package/assets/skills/create-pdf/SKILL.md

@@ -55,13 +55,13 @@ Invoke the skill tool. Flags:
 Single-file example:
 
 ```bash
-node --experimental-strip-types ~/.pal/skills/create-pdf/tools/md-to-html-pdf.ts /path/to/report.md --pdf /path/to/report.pdf
+node ~/.pal/skills/create-pdf/tools/md-to-html-pdf.mjs /path/to/report.md --pdf /path/to/report.pdf
 ```
 
 Multi-file example (after Step 2):
 
 ```bash
-node --experimental-strip-types ~/.pal/skills/create-pdf/tools/md-to-html-pdf.ts /tmp/combined.md --pdf /path/to/report.pdf --html /path/to/report.html
+node ~/.pal/skills/create-pdf/tools/md-to-html-pdf.mjs /tmp/combined.md --pdf /path/to/report.pdf --html /path/to/report.html
 ```
 
 The tool writes the self-contained HTML (inline CSS, UTF-8) and the PDF, and prints both paths + sizes on stdout.
@@ -82,13 +82,13 @@ Default styling (A4, 25mm margins, GitHub-ish look, table-friendly, page-break-a
 - `--header <html|file>` / `--footer <html|file>` — running header/footer on every page. The value is either an inline HTML string or a path to an HTML file. Templates may use Playwright's injected classes: `pageNumber`, `totalPages`, `date`, `title`, `url`.
 
 ```bash
-node --experimental-strip-types ~/.pal/skills/create-pdf/tools/md-to-html-pdf.ts report.md --pdf report.pdf \
+node ~/.pal/skills/create-pdf/tools/md-to-html-pdf.mjs report.md --pdf report.pdf \
   --margin 18mm \
   --header '<div style="font-size:9px;width:100%;text-align:center;color:#888">CONFIDENTIAL</div>' \
   --footer '<div style="font-size:9px;width:100%;text-align:right;padding-right:12mm;color:#888"><span class="pageNumber"></span>/<span class="totalPages"></span></div>'
 ```
 
-Header/footer templates **need an explicit `font-size`** (Playwright defaults them to 0) and render *inside* the page margin — widen `--margin` so they have room. Do NOT also add CSS `@page` margin-box rules; they duplicate. For deeper changes (fonts, base CSS), edit the `css` string in `tools/md-to-html-pdf.ts`.
+Header/footer templates **need an explicit `font-size`** (Playwright defaults them to 0) and render *inside* the page margin — widen `--margin` so they have room. Do NOT also add CSS `@page` margin-box rules; they duplicate. For deeper changes (fonts, base CSS), edit the `css` string in `tools/md-to-html-pdf.ts` (the `.mjs` is generated from it — never edit the `.mjs`).
 
 ## Translation Variant
 

package/assets/skills/create-pdf/tools/md-to-html-pdf.mjs

@@ -0,0 +1,103 @@
+import { readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { marked } from "marked";
+import { chromium } from "playwright";
+const args = process.argv.slice(2);
+if (args.length === 0) {
+  console.error("usage: md-to-html-pdf.ts <input.md> [--html <out>] [--pdf <out>] [--margin <css>] [--header <html|file>] [--footer <html|file>]");
+  process.exit(1);
+}
+const input = resolve(args[0]);
+let htmlOut = "";
+let pdfOut = "";
+let margin = "25mm";
+let headerArg = "";
+let footerArg = "";
+for (let i = 1;i < args.length; i++) {
+  if (args[i] === "--html")
+    htmlOut = resolve(args[++i]);
+  else if (args[i] === "--pdf")
+    pdfOut = resolve(args[++i]);
+  else if (args[i] === "--margin")
+    margin = args[++i];
+  else if (args[i] === "--header")
+    headerArg = args[++i];
+  else if (args[i] === "--footer")
+    footerArg = args[++i];
+}
+const stem = basename(input, extname(input));
+const dir = dirname(input);
+htmlOut ||= resolve(dir, `${stem}.html`);
+pdfOut ||= resolve(dir, `${stem}.pdf`);
+async function resolveTemplate(value) {
+  if (!value)
+    return "";
+  try {
+    return await readFile(resolve(value), "utf8");
+  } catch {
+    return value;
+  }
+}
+const headerTemplate = await resolveTemplate(headerArg);
+const footerTemplate = await resolveTemplate(footerArg);
+const displayHeaderFooter = Boolean(headerTemplate || footerTemplate);
+const md = await readFile(input, "utf8");
+marked.setOptions({ gfm: true, breaks: false });
+const body = await marked.parse(md);
+const css = `
+html { -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+  font-size: 11px; line-height: 1.6; color: #1a1a1a; margin: 0;
+}
+h1 { font-size: 22px; border-bottom: 2px solid #333; padding-bottom: 8px; margin-top: 0; }
+h2 { font-size: 17px; margin-top: 1.6em; }
+h3 { font-size: 14px; }
+h1, h2, h3, h4 { page-break-after: avoid; }
+p, li { orphans: 3; widows: 3; }
+hr { border: none; border-top: 1px solid #ccc; margin: 20px 0; }
+a { color: #0366d6; text-decoration: none; }
+blockquote { border-left: 3px solid #666; padding-left: 12px; color: #444; margin: 12px 0; }
+code { background: #f4f4f4; padding: 1px 4px; border-radius: 3px; font-size: 10px; }
+pre { background: #f4f4f4; padding: 10px; border-radius: 4px; overflow-x: auto; }
+pre code { background: transparent; padding: 0; }
+table { border-collapse: collapse; width: 100%; margin: 12px 0; page-break-inside: avoid; }
+th, td { border: 1px solid #ccc; padding: 6px 10px; text-align: left; font-size: 10px; vertical-align: top; }
+th { background: #f0f0f0; }
+tr { page-break-inside: avoid; }
+ul, ol { padding-left: 1.4em; }
+`;
+const html = `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>${stem}</title>
+<style>${css}</style>
+</head>
+<body>
+${body}
+</body>
+</html>
+`;
+await writeFile(htmlOut, html, "utf8");
+const browser = await chromium.launch();
+try {
+  const page = await browser.newPage();
+  await page.goto(pathToFileURL(htmlOut).href, { waitUntil: "networkidle" });
+  await page.pdf({
+    path: pdfOut,
+    format: "A4",
+    margin: { top: margin, right: margin, bottom: margin, left: margin },
+    printBackground: true,
+    preferCSSPageSize: false,
+    displayHeaderFooter,
+    headerTemplate: headerTemplate || "<span></span>",
+    footerTemplate: footerTemplate || "<span></span>"
+  });
+} finally {
+  await browser.close();
+}
+const [htmlStat, pdfStat] = await Promise.all([stat(htmlOut), stat(pdfOut)]);
+console.log(`HTML: ${htmlOut} (${(htmlStat.size / 1024).toFixed(1)} KB)`);
+console.log(`PDF:  ${pdfOut} (${(pdfStat.size / 1024).toFixed(1)} KB)`);

package/assets/skills/create-pdf/tools/md-to-html-pdf.ts

@@ -6,8 +6,11 @@
 // because it uses --remote-debugging-pipe over stdio and Bun's Windows child-process
 // pipe handling doesn't complete the CDP handshake.
 //
+// pal-build:mjs — ships as a compiled md-to-html-pdf.mjs sibling (scripts/build-skill-tools.ts)
+// and is invoked as that .mjs: a .ts under node_modules can't be type-stripped by Node.
+//
 // Usage:
-//   node --experimental-strip-types ~/.pal/skills/create-pdf/tools/md-to-html-pdf.ts <input.md> \
+//   node ~/.pal/skills/create-pdf/tools/md-to-html-pdf.mjs <input.md> \
 //     [--html <out.html>] [--pdf <out.pdf>] [--margin <css>] [--header <html|file>] [--footer <html|file>]
 //   --margin defaults to 25mm (all sides). --header/--footer accept inline HTML or a file path.
 

package/assets/skills/playwright/SKILL.md

@@ -23,7 +23,7 @@ If neither engine is usable, the tool prints `NO_PLAYWRIGHT_CLI` and exits non-z
 2. Run the tool (it prints the absolute PNG path as its last stdout line):
 
    ```bash
-   node --experimental-strip-types ~/.pal/skills/playwright/tools/shot.ts <url> \
+   node ~/.pal/skills/playwright/tools/shot.mjs <url> \
      [--viewport 1440x900] [--full-page] [--selector "<css>"] [-o <out.png>]
    ```
 

package/assets/skills/playwright/tools/shot-lib.mjs

@@ -0,0 +1,44 @@
+const USAGE = "usage: shot.ts <url> [-o <file>] [--viewport WxH] [--full-page] [--selector <css>] [--wait <ms>]";
+export function parseArgs(argv) {
+  let url = "";
+  let out = "";
+  let viewport;
+  let fullPage = false;
+  let selector;
+  let waitMs;
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-o" || a === "--out")
+      out = argv[++i] ?? "";
+    else if (a === "--viewport") {
+      const m = /^(\d+)[x,](\d+)$/.exec(argv[++i] ?? "");
+      if (!m)
+        throw new Error("--viewport expects WxH, e.g. 1440x900");
+      viewport = { width: Number(m[1]), height: Number(m[2]) };
+    } else if (a === "--full-page")
+      fullPage = true;
+    else if (a === "--selector")
+      selector = argv[++i];
+    else if (a === "--wait") {
+      const n = Number(argv[++i]);
+      if (!Number.isFinite(n))
+        throw new Error("--wait expects a number of milliseconds");
+      waitMs = n;
+    } else if (!a.startsWith("-") && !url)
+      url = a;
+    else
+      throw new Error(`unknown argument: ${a}
+${USAGE}`);
+  }
+  if (!url)
+    throw new Error(`a URL is required
+${USAGE}`);
+  return { url, out, viewport, fullPage, selector, waitMs };
+}
+export function chooseTier(opts) {
+  if (!opts.cliAvailable)
+    return "node";
+  if (opts.viewport || opts.fullPage)
+    return "node";
+  return "cli";
+}

package/assets/skills/playwright/tools/shot.mjs

@@ -0,0 +1,89 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { chooseTier, parseArgs } from "./shot-lib.mjs";
+function playwrightCliAvailable() {
+  try {
+    return spawnSync("playwright-cli", ["--version"], { stdio: "ignore" }).status === 0;
+  } catch {
+    return false;
+  }
+}
+function runViaCli(opts, out) {
+  const work = mkdtempSync(join(tmpdir(), "pal-pwcli-"));
+  const run = (args, quiet = false) => spawnSync("playwright-cli", args, { stdio: quiet ? "ignore" : "inherit", cwd: work });
+  try {
+    if (run(["open", opts.url]).status !== 0)
+      return false;
+    const args = ["screenshot", `--filename=${out}`];
+    if (opts.selector)
+      args.push(opts.selector);
+    const shot = run(args);
+    run(["close"], true);
+    return shot.status === 0 && existsSync(out);
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+async function runViaNode(opts, out) {
+  let chromium;
+  try {
+    ({ chromium } = await import("playwright"));
+  } catch {
+    return "unavailable";
+  }
+  let browser;
+  try {
+    browser = await chromium.launch();
+  } catch (e) {
+    console.error(`chromium launch failed: ${e.message}`);
+    return "unavailable";
+  }
+  try {
+    const page = await browser.newPage(opts.viewport ? { viewport: opts.viewport } : {});
+    await page.goto(opts.url, { waitUntil: "networkidle" });
+    if (opts.waitMs)
+      await page.waitForTimeout(opts.waitMs);
+    if (opts.selector)
+      await page.locator(opts.selector).screenshot({ path: out });
+    else
+      await page.screenshot({ path: out, fullPage: opts.fullPage });
+    return existsSync(out) ? "ok" : "error";
+  } catch (e) {
+    console.error(`screenshot failed: ${e.message}`);
+    return "error";
+  } finally {
+    await browser.close();
+  }
+}
+async function main() {
+  let opts;
+  try {
+    opts = parseArgs(process.argv.slice(2));
+  } catch (e) {
+    console.error(e.message);
+    process.exit(2);
+  }
+  const out = opts.out ? resolve(opts.out) : join(tmpdir(), `pal-shot-${Date.now()}.png`);
+  const tier = chooseTier({
+    cliAvailable: playwrightCliAvailable(),
+    viewport: opts.viewport,
+    fullPage: opts.fullPage
+  });
+  if (tier === "cli" && runViaCli(opts, out)) {
+    console.log(out);
+    return;
+  }
+  const result = await runViaNode(opts, out);
+  if (result === "ok") {
+    console.log(out);
+    return;
+  }
+  if (result === "unavailable") {
+    console.error("NO_PLAYWRIGHT_CLI");
+    process.exit(3);
+  }
+  process.exit(1);
+}
+await main();

package/assets/skills/playwright/tools/shot.ts

@@ -9,8 +9,10 @@
 // If neither engine works, prints NO_PLAYWRIGHT_CLI on stderr and exits non-zero so the
 // caller (SKILL.md) can fall back to the Playwright MCP.
 //
-// Run with Node:
-//   node --experimental-strip-types ~/.pal/skills/playwright/tools/shot.ts <url> [opts]
+// pal-build:mjs — ships as a compiled shot.mjs sibling (scripts/build-skill-tools.ts).
+// Run under Node via the compiled file (a .ts under node_modules can't be type-stripped;
+// plain .mjs needs no stripping and runs on every OS, keeping the Windows fallback):
+//   node ~/.pal/skills/playwright/tools/shot.mjs <url> [opts]
 
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdtempSync, rmSync } from "node:fs";

package/assets/templates/settings.claude.json

@@ -18,6 +18,20 @@
       "Bash(stat //*)",
       "Bash(readlink //*)",
       "Bash(lsof *)",
+      "Bash(rtk read *)",
+      "Bash(rtk ls *)",
+      "Bash(rtk tree *)",
+      "Bash(rtk find *)",
+      "Bash(rtk grep *)",
+      "Bash(rtk rg *)",
+      "Bash(rtk wc *)",
+      "Bash(rtk diff *)",
+      "Bash(rtk json *)",
+      "Bash(rtk log *)",
+      "Bash(rtk deps *)",
+      "Bash(rtk env *)",
+      "Bash(rtk smart *)",
+      "Bash(rtk gain *)",
       "Bash(bun ~/.pal/skills/*/tools/*.ts *)",
       "Bash(bun ~/.pal/tools/*.ts *)",
       "Bash(node --experimental-strip-types ~/.pal/skills/consulting-report/tools/generate-pdf.ts *)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.62.0",
+  "version": "0.62.2",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {
@@ -46,6 +46,8 @@
     "jscpd": "jscpd --noTips",
     "lint-staged": "lint-staged",
     "prepare": "bun .husky/install.mjs",
+    "build:skill-tools": "bun run scripts/build-skill-tools.ts",
+    "prepack": "bun run build:skill-tools",
     "install:all": "bun run src/cli/index.ts cli install",
     "uninstall": "bun run src/cli/index.ts cli uninstall",
     "tool:synthesize": "bun run src/tools/agent/synthesize.ts",

package/src/hooks/lib/models.ts

@@ -26,17 +26,24 @@ export function flagshipAuthorModel(agent: AgentType): string | undefined {
   return FLAGSHIP_AUTHOR_MODEL[agent];
 }
 
+export interface ModelPricing {
+  input: number;
+  output: number;
+  cacheWrite5m: number;
+  cacheWrite1h: number;
+  cacheRead: number;
+}
+
+export interface TokenUsage {
+  input: number;
+  output: number;
+  cacheWrite5m: number;
+  cacheWrite1h: number;
+  cacheRead: number;
+}
+
 /** Pricing per million tokens (USD) — from https://platform.claude.com/docs/en/about-claude/pricing */
-export const MODEL_PRICING: Record<
-  string,
-  {
-    input: number;
-    output: number;
-    cacheWrite5m: number;
-    cacheWrite1h: number;
-    cacheRead: number;
-  }
-> = {
+export const MODEL_PRICING: Record<string, ModelPricing> = {
   [HAIKU_MODEL]: {
     input: 1,
     output: 5,
@@ -51,6 +58,13 @@ export const MODEL_PRICING: Record<
     cacheWrite1h: 20,
     cacheRead: 1,
   },
+  "claude-opus-5": {
+    input: 5,
+    output: 25,
+    cacheWrite5m: 6.25,
+    cacheWrite1h: 10,
+    cacheRead: 0.5,
+  },
   "claude-opus-4-8": {
     input: 5,
     output: 25,
@@ -72,6 +86,13 @@ export const MODEL_PRICING: Record<
     cacheWrite1h: 10,
     cacheRead: 0.5,
   },
+  "claude-opus-4-5": {
+    input: 5,
+    output: 25,
+    cacheWrite5m: 6.25,
+    cacheWrite1h: 10,
+    cacheRead: 0.5,
+  },
   // Claude Sonnet 5 — introductory pricing through 2026-08-31; standard (3/15/3.75/6/0.30) applies from 2026-09-01.
   "claude-sonnet-5": {
     input: 2,
@@ -95,3 +116,37 @@ export const MODEL_PRICING: Record<
     cacheRead: 0.3,
   },
 };
+
+function longestPrefixKey(model: string): string | null {
+  let best: string | null = null;
+  for (const key of Object.keys(MODEL_PRICING)) {
+    if (model.startsWith(key) && (best === null || key.length > best.length)) best = key;
+  }
+  return best;
+}
+
+/**
+ * Rates for a model ID. Transcripts carry variants of the same model — dated
+ * (`claude-opus-5-20260115`) and context-tagged (`claude-opus-5[1m]`) — so an
+ * exact miss falls back to the longest table key the ID starts with.
+ */
+export function pricingFor(model: string): ModelPricing | null {
+  const exact = MODEL_PRICING[model];
+  if (exact) return exact;
+  const prefix = longestPrefixKey(model);
+  return prefix ? MODEL_PRICING[prefix] : null;
+}
+
+/** USD cost of a token usage record. Unpriced models bill as 0. */
+export function costOfUsage(model: string, usage: TokenUsage): number {
+  const p = pricingFor(model);
+  if (!p) return 0;
+  return (
+    (usage.input * p.input +
+      usage.output * p.output +
+      usage.cacheWrite5m * p.cacheWrite5m +
+      usage.cacheWrite1h * p.cacheWrite1h +
+      usage.cacheRead * p.cacheRead) /
+    1_000_000
+  );
+}

package/src/tools/session-summary.ts

@@ -9,7 +9,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { parseArgs } from "node:util";
-import { MODEL_PRICING } from "../hooks/lib/models";
+import { costOfUsage } from "../hooks/lib/models";
 
 // ── Types ──
 
@@ -142,16 +142,13 @@ function parseSession(filepath: string, sessionId: string): Usage {
         : (u.cache_creation_input_tokens ?? 0);
       const cacheWrite1h = cw1h ?? 0;
 
-      const p = MODEL_PRICING[model];
-      if (p) {
-        usage.cost +=
-          (input * p.input +
-            output * p.output +
-            cacheWrite5m * p.cacheWrite5m +
-            cacheWrite1h * p.cacheWrite1h +
-            cr * p.cacheRead) /
-          1_000_000;
-      }
+      usage.cost += costOfUsage(model, {
+        input,
+        output,
+        cacheWrite5m,
+        cacheWrite1h,
+        cacheRead: cr,
+      });
 
       usage.input += input;
       usage.output += output;

package/src/tools/token-cost.ts

@@ -13,7 +13,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { parseArgs } from "node:util";
-import { MODEL_PRICING } from "../hooks/lib/models";
+import { costOfUsage } from "../hooks/lib/models";
 import { palHome } from "../hooks/lib/paths";
 import { findBinaryOnPath } from "../hooks/lib/which";
 
@@ -59,34 +59,6 @@ function emptyTimeBuckets(): TimeBuckets {
 
 // ── Helpers ──
 
-function findPricing(model: string): (typeof MODEL_PRICING)[string] | null {
-  if (MODEL_PRICING[model]) return MODEL_PRICING[model];
-  for (const key of Object.keys(MODEL_PRICING)) {
-    if (model.startsWith(key)) return MODEL_PRICING[key];
-  }
-  return null;
-}
-
-function costForUsage(
-  model: string,
-  input: number,
-  output: number,
-  cacheWrite5m: number,
-  cacheWrite1h: number,
-  cacheRead: number
-): number {
-  const p = findPricing(model);
-  if (!p) return 0;
-  return (
-    (input * p.input +
-      output * p.output +
-      cacheWrite5m * p.cacheWrite5m +
-      cacheWrite1h * p.cacheWrite1h +
-      cacheRead * p.cacheRead) /
-    1_000_000
-  );
-}
-
 function addToBucket(
   bucket: Bucket,
   model: string,
@@ -101,14 +73,13 @@ function addToBucket(
   bucket.cacheWrite5m += cacheWrite5m;
   bucket.cacheWrite1h += cacheWrite1h;
   bucket.cacheRead += cacheRead;
-  bucket.cost += costForUsage(
-    model,
+  bucket.cost += costOfUsage(model, {
     input,
     output,
     cacheWrite5m,
     cacheWrite1h,
-    cacheRead
-  );
+    cacheRead,
+  });
   bucket.calls++;
 }