libretto 0.5.3-experimental.5 → 0.5.3

package/dist/shared/run/browser.js

@@ -1,8 +1,14 @@
-import { chromium } from "playwright";
+import {
+  chromium
+} from "playwright";
 import { createServer } from "node:net";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { ensureLibrettoSessionStatePath } from "../paths/paths.js";
-import { SESSION_STATE_VERSION, SessionStateFileSchema } from "../state/session-state.js";
+import {
+  SESSION_STATE_VERSION,
+  SessionStateFileSchema
+} from "../state/session-state.js";
+import { readLibrettoConfig } from "../../cli/core/ai-config.js";
 async function pickFreePort() {
   return await new Promise((resolve, reject) => {
     const server = createServer();
@@ -18,6 +24,41 @@ async function pickFreePort() {
     });
   });
 }
+function resolveWindowPosition() {
+  return readLibrettoConfig().windowPosition;
+}
+async function applyWindowPosition(browser, context, page, windowPosition) {
+  if (!windowPosition) {
+    return;
+  }
+  const requestedBounds = {
+    left: windowPosition.x,
+    top: windowPosition.y,
+    windowState: "normal"
+  };
+  const pageCdp = await context.newCDPSession(page);
+  let browserCdp;
+  try {
+    const targetInfo = await pageCdp.send("Target.getTargetInfo");
+    const targetId = targetInfo.targetInfo?.targetId;
+    browserCdp = await browser.newBrowserCDPSession();
+    const windowResult = await browserCdp.send(
+      "Browser.getWindowForTarget",
+      targetId ? { targetId } : {}
+    );
+    await browserCdp.send("Browser.setWindowBounds", {
+      windowId: windowResult.windowId,
+      bounds: requestedBounds
+    });
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  } catch {
+  } finally {
+    await pageCdp.detach().catch(() => {
+    });
+    await browserCdp?.detach().catch(() => {
+    });
+  }
+}
 async function launchBrowser({
   sessionName,
   headless = false,
@@ -25,12 +66,14 @@ async function launchBrowser({
   storageStatePath
 }) {
   const debugPort = await pickFreePort();
+  const windowPosition = headless ? void 0 : resolveWindowPosition();
   const browser = await chromium.launch({
     headless,
     args: [
       "--disable-blink-features=AutomationControlled",
       `--remote-debugging-port=${debugPort}`,
-      "--no-focus-on-check"
+      "--no-focus-on-check",
+      ...windowPosition ? [`--window-position=${windowPosition.x},${windowPosition.y}`] : []
     ]
   });
   const context = await browser.newContext({
@@ -38,6 +81,7 @@ async function launchBrowser({
     ...storageStatePath ? { storageState: storageStatePath } : {}
   });
   const page = await context.newPage();
+  await applyWindowPosition(browser, context, page, windowPosition);
   page.setDefaultTimeout(3e4);
   page.setDefaultNavigationTimeout(45e3);
   const metadataPath = ensureLibrettoSessionStatePath(sessionName);

package/dist/shared/state/session-state.d.ts

@@ -15,7 +15,8 @@ declare const SessionViewportSchema: z.ZodObject<{
 declare const SessionStateFileSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     port: z.ZodNumber;
-    pid: z.ZodNumber;
+    pid: z.ZodOptional<z.ZodNumber>;
+    cdpEndpoint: z.ZodOptional<z.ZodString>;
     session: z.ZodString;
     startedAt: z.ZodString;
     status: z.ZodOptional<z.ZodEnum<{

package/dist/shared/state/session-state.js

@@ -14,7 +14,8 @@ const SessionViewportSchema = z.object({
 const SessionStateFileSchema = z.object({
   version: z.literal(SESSION_STATE_VERSION),
   port: z.number().int().min(0).max(65535),
-  pid: z.number().int(),
+  pid: z.number().int().optional(),
+  cdpEndpoint: z.string().url().optional(),
   session: z.string().min(1),
   startedAt: z.string().datetime({ offset: true }),
   status: SessionStatusSchema.optional(),
@@ -29,7 +30,9 @@ function formatIssues(error) {
 function parseSessionStateData(rawState, source) {
   const parsed = SessionStateFileSchema.safeParse(rawState);
   if (!parsed.success) {
-    throw new Error(`Session state at ${source} is invalid: ${formatIssues(parsed.error)}`);
+    throw new Error(
+      `Session state at ${source} is invalid: ${formatIssues(parsed.error)}`
+    );
   }
   const { version: _version, ...state } = parsed.data;
   return state;

package/dist/shared/visualization/ghost-cursor.js

@@ -1,7 +1,7 @@
 const DEFAULTS = {
   style: "minimal",
   color: "rgba(255, 70, 70, 0.9)",
-  size: 20,
+  size: 23,
   zIndex: 2147483646,
   easing: "cubic-bezier(0.16, 1, 0.3, 1)",
   minDurationMs: 100,
@@ -16,19 +16,32 @@ function buildCursorSvg(style, color, size) {
   if (style === "screenstudio") {
     return `<div style="width:${size * 1.4}px;height:${size * 1.4}px;border-radius:50%;background:${color};box-shadow:0 0 ${size * 0.6}px ${color};opacity:0.7;"></div>`;
   }
-  return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" style="display:block;filter:drop-shadow(0 2px 6px rgba(15,23,42,0.22));">
 		<path d="M5 3L19 12L12 13L9 20L5 3Z" fill="${color}" stroke="rgba(0,0,0,0.3)" stroke-width="1"/>
 	</svg>`;
 }
+function buildCursorMarkup(style, color, size) {
+  const cursor = buildCursorSvg(style, color, size);
+  const badgeHeight = Math.max(12, Math.round(size * 0.54));
+  const fontSize = Math.max(8, Math.round(size * 0.28));
+  const minWidth = Math.max(28, Math.round(size * 1.28));
+  const paddingX = Math.max(5, Math.round(size * 0.2));
+  const left = Math.round(size * 0.84);
+  const top = Math.round(size * 0.74);
+  const width = Math.round(size * 2.4);
+  const height = Math.round(size * 1.95);
+  const badge = `<div aria-hidden="true" style="position:absolute;left:${left}px;top:${top}px;display:flex;align-items:center;justify-content:center;min-width:${minWidth}px;height:${badgeHeight}px;padding:0 ${paddingX}px;border-radius:${badgeHeight}px;background:${color};color:rgba(255,255,255,0.96);font:700 ${fontSize}px/1 ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;letter-spacing:0.02em;white-space:nowrap;border:1px solid rgba(0,0,0,0.16);box-shadow:0 4px 12px rgba(0,0,0,0.14);transform-origin:left center;">Agent</div>`;
+  return `<div style="position:relative;width:${width}px;height:${height}px;overflow:visible;">${cursor}${badge}</div>`;
+}
 function buildInitScript(opts) {
-  const svg = buildCursorSvg(opts.style, opts.color, opts.size);
+  const markup = buildCursorMarkup(opts.style, opts.color, opts.size);
   return `
 (function() {
 	if (document.getElementById("${CURSOR_ID}")) return;
 	var el = document.createElement("div");
 	el.id = "${CURSOR_ID}";
 	el.style.cssText = "position:fixed;top:0;left:0;z-index:${opts.zIndex};pointer-events:none;transform:translate3d(-100px,-100px,0);transition:none;will-change:transform,opacity;opacity:0;";
-	el.innerHTML = ${JSON.stringify(svg)};
+	el.innerHTML = ${JSON.stringify(markup)};
 	document.documentElement.appendChild(el);
 })();
 `;
@@ -64,7 +77,13 @@ async function moveGhostCursor(page, target) {
         el.style.transition = `transform ${duration}ms ${easing}`;
         el.style.transform = `translate3d(${x}px, ${y}px, 0)`;
       },
-      { id: CURSOR_ID, x: target.x, y: target.y, duration: durationMs, easing: opts.easing }
+      {
+        id: CURSOR_ID,
+        x: target.x,
+        y: target.y,
+        duration: durationMs,
+        easing: opts.easing
+      }
     );
     await page.waitForTimeout(durationMs);
   } catch {
@@ -122,15 +141,18 @@ async function hideGhostCursor(page) {
 }
 async function getGhostCursorPosition(page) {
   try {
-    return await page.evaluate(({ id }) => {
-      const el = document.getElementById(id);
-      if (!el) return null;
-      const match = el.style.transform.match(
-        /translate3d\(\s*([\d.-]+)px\s*,\s*([\d.-]+)px/
-      );
-      if (!match) return null;
-      return { x: parseFloat(match[1]), y: parseFloat(match[2]) };
-    }, { id: CURSOR_ID });
+    return await page.evaluate(
+      ({ id }) => {
+        const el = document.getElementById(id);
+        if (!el) return null;
+        const match = el.style.transform.match(
+          /translate3d\(\s*([\d.-]+)px\s*,\s*([\d.-]+)px/
+        );
+        if (!match) return null;
+        return { x: parseFloat(match[1]), y: parseFloat(match[2]) };
+      },
+      { id: CURSOR_ID }
+    );
   } catch {
     return null;
   }

package/dist/shared/visualization/highlight.js

@@ -92,12 +92,15 @@ async function showHighlight(page, params) {
 }
 async function clearHighlights(page) {
   try {
-    await page.evaluate(({ layerId }) => {
-      const layer = document.getElementById(layerId);
-      if (!layer) return;
-      const rects = layer.querySelectorAll(".__libretto_highlight_rect__");
-      rects.forEach((r) => r.remove());
-    }, { layerId: LAYER_ID });
+    await page.evaluate(
+      ({ layerId }) => {
+        const layer = document.getElementById(layerId);
+        if (!layer) return;
+        const rects = layer.querySelectorAll(".__libretto_highlight_rect__");
+        rects.forEach((r) => r.remove());
+      },
+      { layerId: LAYER_ID }
+    );
   } catch {
   }
 }

package/dist/shared/workflow/workflow.d.ts

@@ -2,20 +2,28 @@ import { Page } from 'playwright';
 import { MinimalLogger } from '../logger/logger.js';
 
 declare const LIBRETTO_WORKFLOW_BRAND: unique symbol;
-type LibrettoWorkflowMetadata = {};
-type LibrettoWorkflowContext<S = {}> = {
+type LibrettoWorkflowContext = {
+    session: string;
     page: Page;
     logger: MinimalLogger;
-    services: S;
 };
-type LibrettoWorkflowHandler<Input = unknown, Output = unknown, S = {}> = (ctx: LibrettoWorkflowContext<S>, input: Input) => Promise<Output>;
-declare class LibrettoWorkflow<Input = unknown, Output = unknown, S = {}> {
+type LibrettoWorkflowHandler<Input = unknown, Output = unknown> = (ctx: LibrettoWorkflowContext, input: Input) => Promise<Output>;
+declare class LibrettoWorkflow<Input = unknown, Output = unknown> {
     readonly [LIBRETTO_WORKFLOW_BRAND] = true;
-    readonly metadata: LibrettoWorkflowMetadata;
+    readonly name: string;
     private readonly handler;
-    constructor(metadata: LibrettoWorkflowMetadata, handler: LibrettoWorkflowHandler<Input, Output, S>);
-    run(ctx: LibrettoWorkflowContext<S>, input: Input): Promise<Output>;
+    constructor(name: string, handler: LibrettoWorkflowHandler<Input, Output>);
+    run(ctx: LibrettoWorkflowContext, input: Input): Promise<Output>;
 }
-declare function workflow<Input = unknown, Output = unknown, S = {}>(metadata: LibrettoWorkflowMetadata, handler: LibrettoWorkflowHandler<Input, Output, S>): LibrettoWorkflow<Input, Output, S>;
+type ExportedLibrettoWorkflow = {
+    readonly [LIBRETTO_WORKFLOW_BRAND]: true;
+    readonly name: string;
+    run: (ctx: LibrettoWorkflowContext, input: unknown) => Promise<unknown>;
+};
+type WorkflowModuleExports = Record<string, unknown>;
+declare function isLibrettoWorkflow(value: unknown): value is ExportedLibrettoWorkflow;
+declare function getWorkflowsFromModuleExports(moduleExports: WorkflowModuleExports): ExportedLibrettoWorkflow[];
+declare function getWorkflowFromModuleExports(moduleExports: WorkflowModuleExports, workflowName: string): ExportedLibrettoWorkflow | null;
+declare function workflow<Input = unknown, Output = unknown>(name: string, handler: LibrettoWorkflowHandler<Input, Output>): LibrettoWorkflow<Input, Output>;
 
-export { LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, type LibrettoWorkflowContext, type LibrettoWorkflowHandler, type LibrettoWorkflowMetadata, workflow };
+export { type ExportedLibrettoWorkflow, LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, type LibrettoWorkflowContext, type LibrettoWorkflowHandler, getWorkflowFromModuleExports, getWorkflowsFromModuleExports, isLibrettoWorkflow, workflow };

package/dist/shared/workflow/workflow.js

@@ -1,21 +1,66 @@
 const LIBRETTO_WORKFLOW_BRAND = /* @__PURE__ */ Symbol.for("libretto.workflow");
 class LibrettoWorkflow {
   [LIBRETTO_WORKFLOW_BRAND] = true;
-  metadata;
+  name;
   handler;
-  constructor(metadata, handler) {
-    this.metadata = metadata;
+  constructor(name, handler) {
+    this.name = name;
     this.handler = handler;
   }
   async run(ctx, input) {
     return this.handler(ctx, input);
   }
 }
-function workflow(metadata, handler) {
-  return new LibrettoWorkflow(metadata, handler);
+function isLibrettoWorkflow(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate[LIBRETTO_WORKFLOW_BRAND] === true && typeof candidate.name === "string" && typeof candidate.run === "function";
+}
+function addWorkflowOrThrow(workflowsByName, value) {
+  if (!isLibrettoWorkflow(value)) return;
+  const existing = workflowsByName.get(value.name);
+  if (existing && existing !== value) {
+    throw new Error(
+      `Duplicate workflow name: "${value.name}". Each workflow() call must use a unique name.`
+    );
+  }
+  workflowsByName.set(value.name, value);
+}
+function getWorkflowsFromModuleExports(moduleExports) {
+  const workflowsByName = /* @__PURE__ */ new Map();
+  for (const [exportName, value] of Object.entries(moduleExports)) {
+    if (exportName === "workflows" && value && typeof value === "object") {
+      if (isLibrettoWorkflow(value)) {
+        addWorkflowOrThrow(workflowsByName, value);
+      } else {
+        for (const nestedValue of Object.values(
+          value
+        )) {
+          addWorkflowOrThrow(workflowsByName, nestedValue);
+        }
+      }
+      continue;
+    }
+    addWorkflowOrThrow(workflowsByName, value);
+  }
+  return [...workflowsByName.values()];
+}
+function getWorkflowFromModuleExports(moduleExports, workflowName) {
+  for (const workflow2 of getWorkflowsFromModuleExports(moduleExports)) {
+    if (workflow2.name === workflowName) {
+      return workflow2;
+    }
+  }
+  return null;
+}
+function workflow(name, handler) {
+  return new LibrettoWorkflow(name, handler);
 }
 export {
   LIBRETTO_WORKFLOW_BRAND,
   LibrettoWorkflow,
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
+  isLibrettoWorkflow,
   workflow
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libretto",
-  "version": "0.5.3-experimental.5",
+  "version": "0.5.3",
   "description": "AI-powered browser automation library and CLI built on Playwright",
   "license": "MIT",
   "repository": {
@@ -31,15 +31,16 @@
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.mjs",
-    "check:skills": "node scripts/check-skills-sync.mjs",
+    "sync:mirrors": "node ../dev-tools/scripts/sync-mirrors.mjs",
+    "check:mirrors": "node ../dev-tools/scripts/check-mirrors-sync.mjs",
+    "sync-skills": "pnpm run sync:mirrors",
+    "check:skills": "pnpm run check:mirrors",
     "build": "tsup --config tsup.config.ts",
     "type-check": "tsc --noEmit",
     "test": "pnpm run build && vitest run",
-    "eval": "pnpm run build && vitest run --config vitest.evals.config.ts",
-    "benchmark": "pnpm run build && tsx benchmarks/run.ts",
     "test:watch": "vitest",
     "cli": "node dist/index.js",
-    "prepare-release": "bash ./scripts/prepare-release.sh",
+    "generate-changelog": "tsx scripts/generate-changelog.ts",
     "prepack": "pnpm run build"
   },
   "peerDependencies": {
@@ -63,12 +64,18 @@
     }
   },
   "devDependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.75",
     "@ai-sdk/anthropic": "^3.0.58",
     "@ai-sdk/google": "^3.0.51",
     "@ai-sdk/google-vertex": "^4.0.80",
     "@ai-sdk/openai": "^3.0.41",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.75",
+    "@mariozechner/pi-agent-core": "^0.62.0",
+    "@mariozechner/pi-ai": "^0.62.0",
+    "@mariozechner/pi-coding-agent": "^0.62.0",
+    "@sinclair/typebox": "^0.34.48",
     "@types/node": "^25.5.0",
+    "glimpseui": "^0.5.1",
+    "google-auth-library": "^10.6.1",
     "openai": "^6.29.0",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
@@ -76,6 +83,7 @@
   },
   "dependencies": {
     "ai": "^6.0.116",
+    "esbuild": "^0.27.0",
     "playwright": "^1.58.2",
     "tsx": "^4.21.0",
     "zod": "^4.3.6"

package/scripts/generate-changelog.ts

@@ -0,0 +1,132 @@
+import { execFileSync } from "node:child_process";
+import { Agent, type AgentTool, type AgentEvent } from "@mariozechner/pi-agent-core";
+import { getModel } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+
+const tag = process.argv[2];
+if (!tag) {
+  console.error("Usage: generate-changelog.ts <tag>");
+  console.error("Example: generate-changelog.ts v0.5.2");
+  process.exit(1);
+}
+
+if (!process.env.ANTHROPIC_API_KEY) {
+  console.error("ANTHROPIC_API_KEY is required.");
+  process.exit(1);
+}
+
+const ALLOWED_GH_SUBCOMMANDS = new Set(["pr", "release", "repo", "issue"]);
+const ALLOWED_ACTIONS = new Set(["list", "view", "diff", "status", "checks"]);
+
+const ghTool: AgentTool = {
+  name: "gh",
+  label: "GitHub CLI",
+  description: [
+    "Run a read-only GitHub CLI command. The arguments are passed directly to `gh`.",
+    "Examples: 'release list --limit 5', 'pr list --state merged --json number,title',",
+    "'pr view 128 --json title,body,files', 'pr diff 128'.",
+    "Only read operations are allowed (list, view, diff, etc.). Mutating commands will be rejected.",
+  ].join(" "),
+  parameters: Type.Object({
+    args: Type.String({ description: "Arguments to pass to gh (without the leading 'gh')" }),
+  }),
+  execute: async (_toolCallId, rawParams) => {
+    const params = rawParams as { args: string };
+    const args = params.args.trim();
+    const parts = args.split(/\s+/);
+    const subcommand = parts[0];
+
+    if (!subcommand || !ALLOWED_GH_SUBCOMMANDS.has(subcommand)) {
+      throw new Error(`Subcommand '${subcommand}' is not allowed. Allowed: ${[...ALLOWED_GH_SUBCOMMANDS].join(", ")}`);
+    }
+
+    const action = parts[1];
+    if (!action || !ALLOWED_ACTIONS.has(action)) {
+      throw new Error(`Action '${action}' is not allowed. Allowed: ${[...ALLOWED_ACTIONS].join(", ")}`);
+    }
+
+    try {
+      const output = execFileSync("gh", parts, {
+        encoding: "utf8",
+        timeout: 300_000,
+        maxBuffer: 1024 * 1024,
+      });
+      return { content: [{ type: "text", text: output }], details: {} };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`gh command failed: ${message}`);
+    }
+  },
+};
+
+const agent = new Agent({
+  initialState: {
+    systemPrompt: [
+      `Generate release notes for the ${tag} release of Libretto.`,
+      "",
+      "Use the gh tool to explore what changed since the previous release.",
+      "Useful queries:",
+      "- 'release list --limit 5' to find the previous release tag",
+      "- 'pr list --state merged --limit 50 --json number,title,body,labels' to find merged PRs",
+      "- 'pr diff NUMBER' to see the full diff of a PR (base to head, not individual commits)",
+      "- 'pr view NUMBER --json title,body,files' to see PR details",
+      "",
+      "IMPORTANT: Always read the full PR diff to understand what actually changed.",
+      "Do NOT rely solely on PR titles and descriptions — they may be incomplete or misleading.",
+      "The diff is the source of truth for what the release note should say.",
+      "",
+      "Guidelines:",
+      "- Write concise, user-facing release notes in markdown.",
+      "- Group changes into sections like Features, Fixes, and Improvements. Only include sections that have entries.",
+      "- Focus on what changed from the user's perspective, not internal implementation details.",
+      "- Do NOT include PR numbers or links.",
+      "- Skip PRs labeled 'skip-changelog'.",
+      "- Your response must contain ONLY the raw markdown release notes. No preamble like 'Here are the release notes'. No commentary or explanation. No '---' separators. The very first character of your response must be '#'. Example format:",
+      "",
+      "## Features",
+      "",
+      "- **Thing**: Description",
+    ].join("\n"),
+    model: getModel("anthropic", "claude-sonnet-4-6"),
+    tools: [ghTool],
+  },
+});
+
+let finalText = "";
+
+agent.subscribe((event: AgentEvent) => {
+  if (event.type === "agent_end") {
+    const messages = event.messages;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (msg.role === "assistant" && Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (typeof block === "object" && "type" in block && block.type === "text" && "text" in block) {
+            finalText = block.text as string;
+            return;
+          }
+        }
+      }
+    }
+  }
+});
+
+await agent.prompt("Generate the release notes now.");
+
+if (!finalText) {
+  console.error("Changelog generation failed: no text output from agent.");
+  process.exit(1);
+}
+
+// Strip any preamble before the first markdown heading.
+const headingIndex = finalText.indexOf("\n#");
+if (headingIndex >= 0) {
+  finalText = finalText.slice(headingIndex + 1);
+} else if (finalText.startsWith("#")) {
+  // Already starts with a heading, keep as-is.
+} else {
+  console.error("Changelog generation failed: output does not contain markdown headings.");
+  process.exit(1);
+}
+
+process.stdout.write(finalText);

package/scripts/postinstall.mjs

@@ -31,9 +31,10 @@ const gitResult = spawnSync("git", ["rev-parse", "--show-toplevel"], {
   encoding: "utf-8",
   stdio: ["pipe", "pipe", "pipe"],
 });
-const repoRoot = gitResult.status === 0 && gitResult.stdout
-  ? gitResult.stdout.trim()
-  : installCwd;
+const repoRoot =
+  gitResult.status === 0 && gitResult.stdout
+    ? gitResult.stdout.trim()
+    : installCwd;
 
 const sourceDir = join(packageRoot, "skills", "libretto");
 if (!existsSync(sourceDir)) process.exit(0);

package/scripts/skills-libretto.mjs

@@ -1,101 +1,15 @@
 #!/usr/bin/env node
 
-import {
-  cpSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-} from "node:fs";
-import { relative, resolve, join } from "node:path";
+import { cpSync, mkdirSync, rmSync } from "node:fs";
 
 export const SKILL_DIRS = [
-  "skills/libretto",
+  "packages/libretto/skills/libretto",
   ".agents/skills/libretto",
   ".claude/skills/libretto",
 ];
 
-function walkFiles(dir, baseDir = dir) {
-  const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) =>
-    a.name.localeCompare(b.name)
-  );
-  const files = [];
-
-  for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...walkFiles(fullPath, baseDir));
-      continue;
-    }
-    if (entry.isFile()) files.push(relative(baseDir, fullPath));
-  }
-
-  return files;
-}
-
 export function syncSkillDir(sourceDir, destDir) {
   rmSync(destDir, { recursive: true, force: true });
   mkdirSync(destDir, { recursive: true });
   cpSync(sourceDir, destDir, { recursive: true });
 }
-
-export function syncRepoSkills(repoRoot) {
-  const sourceDir = resolve(repoRoot, "skills/libretto");
-  for (const dir of SKILL_DIRS.slice(1)) {
-    syncSkillDir(sourceDir, resolve(repoRoot, dir));
-  }
-}
-
-export function compareSkillDirs(repoRoot) {
-  const roots = SKILL_DIRS.map((dir) => ({
-    label: dir,
-    absPath: resolve(repoRoot, dir),
-  }));
-  const missing = roots.filter(({ absPath }) => !existsSync(absPath));
-  const mismatches = [];
-
-  if (missing.length > 0) {
-    return {
-      ok: false,
-      issues: missing.map(({ label }) => `missing directory: ${label}`),
-    };
-  }
-
-  const expectedFiles = walkFiles(roots[0].absPath);
-  const expectedFileSet = new Set(expectedFiles);
-
-  for (const root of roots.slice(1)) {
-    const actualFiles = walkFiles(root.absPath);
-    const actualFileSet = new Set(actualFiles);
-
-    for (const file of expectedFiles) {
-      if (!actualFileSet.has(file)) {
-        mismatches.push(`${root.label} is missing file: ${file}`);
-      }
-    }
-
-    for (const file of actualFiles) {
-      if (!expectedFileSet.has(file)) {
-        mismatches.push(`${root.label} has unexpected file: ${file}`);
-      }
-    }
-  }
-
-  for (const file of expectedFiles) {
-    const expectedContent = readFileSync(join(roots[0].absPath, file));
-    for (const root of roots.slice(1)) {
-      const targetPath = join(root.absPath, file);
-      if (!existsSync(targetPath)) continue;
-      const actualContent = readFileSync(targetPath);
-      if (!expectedContent.equals(actualContent)) {
-        mismatches.push(`${root.label} differs from ${roots[0].label}: ${file}`);
-      }
-    }
-  }
-
-  return {
-    ok: mismatches.length === 0,
-    issues: mismatches,
-  };
-}