libretto 0.5.2 → 0.5.3-experimental.0

package/README.md

@@ -63,8 +63,9 @@ You can also use Libretto directly from the command line. All commands accept `-
 npx libretto init                          # interactive; run yourself, not through an agent
 npx libretto open <url>                    # launch browser and open a URL (headed by default)
 npx libretto snapshot --objective "..." --context "..."  # capture PNG + HTML and analyze with an LLM
-npx libretto exec "<code>"                 # execute Playwright TypeScript against the open page
-npx libretto run <file> <export>           # run an exported workflow from a file
+npx libretto exec "<code>"                 # execute Playwright TypeScript against the open page (single quoted argument)
+echo "<code>" | npx libretto exec -        # intentionally read Playwright TypeScript from stdin
+npx libretto run <file> <workflowName>     # run an exported workflow from a file
 npx libretto resume                        # resume a paused workflow
 npx libretto network                       # view captured network requests
 npx libretto actions                       # view captured user/agent actions

package/dist/cli/commands/execution.js

@@ -445,9 +445,10 @@ async function runIntegrationFromFile(args, logger) {
   );
   const payload = JSON.stringify({
     integrationPath: args.integrationPath,
-    exportName: args.exportName,
+    workflowName: args.workflowName,
     session: args.session,
     params: args.params,
+    credentials: args.credentials,
     headless: args.headless,
     visualize: args.visualize,
     authProfileDomain: args.authProfileDomain,
@@ -496,11 +497,19 @@ Browser is still open. You can use \`exec\` to inspect it. Call \`run\` to re-ru
   setSessionStatus(args.session, "completed", logger);
   console.log("Integration completed.");
 }
+function readStdinSync() {
+  if (process.stdin.isTTY === true) return null;
+  try {
+    const content = readFileSync(0, "utf8");
+    return content.trim().length > 0 ? content : null;
+  } catch {
+    return null;
+  }
+}
 const execInput = SimpleCLI.input({
   positionals: [
-    SimpleCLI.positional("codeParts", z.array(z.string()).default([]), {
-      help: "Playwright TypeScript code to execute",
-      variadic: true
+    SimpleCLI.positional("code", z.string().optional(), {
+      help: "Playwright TypeScript code to execute"
     })
   ],
   named: {
@@ -511,28 +520,36 @@ const execInput = SimpleCLI.input({
     page: pageOption()
   }
 }).refine(
-  (input) => input.codeParts.length > 0,
-  `Usage: libretto exec <code> [--session <name>] [--visualize]`
+  (input) => input.code !== void 0,
+  `Usage: libretto exec <code|-> [--session <name>] [--visualize]
+       echo '<code>' | libretto exec - [--session <name>] [--visualize]`
 );
 const execCommand = SimpleCLI.command({
   description: "Execute Playwright TypeScript code"
 }).input(execInput).use(withRequiredSession()).handle(async ({ input, ctx }) => {
+  const code = input.code;
+  const codeFromArgsOrStdin = code === "-" ? readStdinSync() : code;
+  if (codeFromArgsOrStdin === null) {
+    throw new Error(
+      "Missing stdin input for `exec -`. Pipe Playwright code into stdin."
+    );
+  }
   await runExec(
-    input.codeParts.join(" "),
+    codeFromArgsOrStdin,
     ctx.session,
     ctx.logger,
     input.visualize,
     input.page
   );
 });
-const runUsage = `Usage: libretto run <integrationFile> <integrationExport> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless] [--no-visualize] [--viewport WxH]`;
+const runUsage = `Usage: libretto run <integrationFile> <workflowName> [--params <json> | --params-file <path>] [--credentials <json>] [--tsconfig <path>] [--headed|--headless] [--no-visualize] [--viewport WxH]`;
 const runInput = SimpleCLI.input({
   positionals: [
     SimpleCLI.positional("integrationFile", z.string().optional(), {
       help: "Path to the integration file"
     }),
-    SimpleCLI.positional("integrationExport", z.string().optional(), {
-      help: "Named workflow export to run"
+    SimpleCLI.positional("workflowName", z.string().optional(), {
+      help: "Workflow name to run (from workflow(name, handler))"
     })
   ],
   named: {
@@ -544,6 +561,9 @@ const runInput = SimpleCLI.input({
       name: "params-file",
       help: "Path to a JSON params file"
     }),
+    credentials: SimpleCLI.option(z.string().optional(), {
+      help: "Inline JSON credentials passed to ctx.credentials"
+    }),
     tsconfig: SimpleCLI.option(z.string().optional(), {
       help: "Path to a tsconfig used for workflow module resolution"
     }),
@@ -562,7 +582,7 @@ const runInput = SimpleCLI.input({
     })
   }
 }).refine(
-  (input) => Boolean(input.integrationFile && input.integrationExport),
+  (input) => Boolean(input.integrationFile && input.workflowName),
   runUsage
 ).refine(
   (input) => !(input.params && input.paramsFile),
@@ -594,6 +614,11 @@ const runCommand = SimpleCLI.command({
   await stopExistingFailedRunSession(ctx.session, ctx.logger);
   assertSessionAvailableForStart(ctx.session, ctx.logger);
   const params = resolveRunParams(input.params, input.paramsFile);
+  const rawCredentials = input.credentials ? parseJsonArg("--credentials", input.credentials) : void 0;
+  if (rawCredentials !== void 0 && (typeof rawCredentials !== "object" || rawCredentials === null || Array.isArray(rawCredentials))) {
+    throw new Error(`--credentials must be a JSON object (e.g., '{"key": "value"}').`);
+  }
+  const credentials = rawCredentials;
   const headlessMode = input.headed ? false : input.headless ? true : void 0;
   const visualize = !input.noVisualize;
   const viewport = resolveViewport(
@@ -603,9 +628,10 @@ const runCommand = SimpleCLI.command({
   await runIntegrationFromFile(
     {
       integrationPath: input.integrationFile,
-      exportName: input.integrationExport,
+      workflowName: input.workflowName,
       session: ctx.session,
       params,
+      credentials,
       tsconfigPath: input.tsconfig,
       headless: headlessMode ?? false,
       visualize,

package/dist/cli/framework/simple-cli.js

@@ -270,6 +270,10 @@ class SimpleCLIApp {
         named["--"] = args.slice(index + 1);
         break;
       }
+      if (arg === "-") {
+        positionals.push(arg);
+        continue;
+      }
       if (arg.startsWith("--")) {
         const [rawName, inlineValue] = splitNamedArg(arg.slice(2));
         const namedEntry = namedSpecs.get(rawName);

package/dist/cli/workers/run-integration-runtime.js

@@ -4,6 +4,8 @@ import { cwd } from "node:process";
 import { isAbsolute, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import {
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
   instrumentContext,
   launchBrowser
 } from "../../index.js";
@@ -19,7 +21,6 @@ import {
   removeSignalIfExists
 } from "../core/pause-signals.js";
 import { installSessionTelemetry } from "../core/session-telemetry.js";
-const LIBRETTO_WORKFLOW_BRAND = /* @__PURE__ */ Symbol.for("libretto.workflow");
 const FAILURE_HOLD_POLL_INTERVAL_MS = 250;
 const TSCONFIG_HINT = "TypeScript compilation failed. Pass --tsconfig <path> to run against a specific tsconfig.";
 function isTsxCompileError(error) {
@@ -67,11 +68,6 @@ async function waitForFailureSessionRelease(args) {
     );
   }
 }
-function isLoadedLibrettoWorkflow(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  return candidate[LIBRETTO_WORKFLOW_BRAND] === true && typeof candidate.run === "function";
-}
 function resolveLocalAuthProfilePath(domain) {
   return getProfilePath(normalizeDomain(domain));
 }
@@ -93,7 +89,7 @@ function getAbsoluteIntegrationPath(integrationPath) {
   }
   return absolutePath;
 }
-async function loadWorkflowExport(absolutePath, exportName) {
+async function loadWorkflowByName(absolutePath, workflowName) {
   let loadedModule;
   try {
     loadedModule = await import(pathToFileURL(absolutePath).href);
@@ -105,37 +101,17 @@ ${TSCONFIG_HINT}` : "";
       `Failed to import integration module at ${absolutePath}: ${message}${compileHint}`
     );
   }
-  const targetExport = loadedModule[exportName];
-  if (!targetExport) {
-    const availableExports = Object.keys(loadedModule);
-    const detail = availableExports.length > 0 ? ` Available exports: ${availableExports.join(", ")}` : " The module has no exports.";
-    throw new Error(
-      `Export "${exportName}" was not found in ${absolutePath}.${detail}`
-    );
-  }
-  if (!isLoadedLibrettoWorkflow(targetExport)) {
-    throw new Error(
-      [
-        `Export "${exportName}" in ${absolutePath} is not a valid Libretto workflow.`,
-        "",
-        'A workflow must be created using the workflow() function from "libretto":',
-        "",
-        '  import { workflow } from "libretto";',
-        "",
-        `  export const ${exportName} = workflow<InputType, OutputType>(`,
-        "    async (ctx, input) => {",
-        "      // ctx.session  \u2014 libretto session name",
-        "      // ctx.page     \u2014 Playwright Page instance",
-        "      // ctx.logger   \u2014 MinimalLogger",
-        "      // ctx.services \u2014 injected dependencies (generic, default {})",
-        "      // input        \u2014 JSON-serializable input matching InputType",
-        "      return output; // must match OutputType",
-        "    },",
-        "  );"
-      ].join("\n")
-    );
+  const workflow = getWorkflowFromModuleExports(loadedModule, workflowName);
+  if (workflow) {
+    return workflow;
   }
-  return targetExport;
+  const availableWorkflows = getWorkflowsFromModuleExports(loadedModule).map(
+    (candidate) => candidate.name
+  );
+  const detail = availableWorkflows.length > 0 ? ` Available workflows: ${availableWorkflows.join(", ")}` : ' No workflows found in this file. Export a workflow() instance from "libretto" directly or via `export const workflows = { ... }`.';
+  throw new Error(
+    `Workflow "${workflowName}" not found in ${absolutePath}.${detail}`
+  );
 }
 async function installHeadedWorkflowVisualization(args) {
   await (args.instrument ?? instrumentContext)(args.context, {
@@ -146,7 +122,7 @@ async function installHeadedWorkflowVisualization(args) {
 async function runIntegrationInternal(args, options) {
   const { logger } = options;
   const absolutePath = getAbsoluteIntegrationPath(args.integrationPath);
-  const workflow = await loadWorkflowExport(absolutePath, args.exportName);
+  const workflow = await loadWorkflowByName(absolutePath, args.workflowName);
   const signalPaths = getPauseSignalPaths(args.session);
   await removeSignalIfExists(signalPaths.pausedSignalPath);
   await removeSignalIfExists(signalPaths.resumeSignalPath);
@@ -154,11 +130,11 @@ async function runIntegrationInternal(args, options) {
   await removeSignalIfExists(signalPaths.failedSignalPath);
   const restoreStdout = mirrorStdoutToFile(signalPaths.outputSignalPath);
   console.log(
-    `Running integration "${args.exportName}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`
+    `Running workflow "${args.workflowName}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`
   );
   const integrationLogger = logger.withScope("integration-run", {
     integrationPath: absolutePath,
-    integrationExport: args.exportName,
+    workflowName: args.workflowName,
     session: args.session
   });
   const authProfileDomain = args.authProfileDomain;
@@ -201,7 +177,8 @@ async function runIntegrationInternal(args, options) {
     session: args.session,
     logger: integrationLogger,
     page: browserSession.page,
-    services: {}
+    services: {},
+    credentials: args.credentials
   };
   try {
     try {

package/dist/cli/workers/run-integration-worker-protocol.js

@@ -1,9 +1,10 @@
 import { z } from "zod";
 const RunIntegrationWorkerRequestSchema = z.object({
   integrationPath: z.string().min(1),
-  exportName: z.string().min(1),
+  workflowName: z.string().min(1),
   session: z.string().min(1),
   params: z.unknown(),
+  credentials: z.record(z.string(), z.unknown()).optional(),
   headless: z.boolean(),
   visualize: z.boolean().default(true),
   authProfileDomain: z.string().optional(),

package/dist/index.d.ts

@@ -14,7 +14,7 @@ export { InstrumentationOptions, InstrumentedPage, installInstrumentation, instr
 export { GhostCursorOptions, ensureGhostCursor, ghostClick, hideGhostCursor, moveGhostCursor } from './shared/visualization/ghost-cursor.js';
 export { HighlightOptions, clearHighlights, ensureHighlightLayer, showHighlight } from './shared/visualization/highlight.js';
 export { BrowserSession, LaunchBrowserArgs, launchBrowser } from './shared/run/browser.js';
-export { LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, workflow } from './shared/workflow/workflow.js';
+export { ExportedLibrettoWorkflow, LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, getWorkflowFromModuleExports, getWorkflowsFromModuleExports, isLibrettoWorkflow, workflow } from './shared/workflow/workflow.js';
 import 'zod';
 import 'ai';
 import 'playwright';

package/dist/index.js

@@ -54,6 +54,9 @@ import {
   launchBrowser
 } from "./shared/run/api.js";
 import {
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
+  isLibrettoWorkflow,
   LibrettoWorkflow,
   LIBRETTO_WORKFLOW_BRAND,
   workflow
@@ -92,11 +95,14 @@ export {
   ensureHighlightLayer,
   executeRecoveryAgent,
   extractFromPage,
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
   ghostClick,
   hideGhostCursor,
   installInstrumentation,
   instrumentContext,
   instrumentPage,
+  isLibrettoWorkflow,
   jsonlConsoleSink,
   launchBrowser,
   moveGhostCursor,

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

@@ -7,14 +7,25 @@ type LibrettoWorkflowContext<S = {}> = {
     page: Page;
     logger: MinimalLogger;
     services: S;
+    credentials?: Record<string, unknown>;
 };
 type LibrettoWorkflowHandler<Input = unknown, Output = unknown, S = {}> = (ctx: LibrettoWorkflowContext<S>, input: Input) => Promise<Output>;
 declare class LibrettoWorkflow<Input = unknown, Output = unknown, S = {}> {
     readonly [LIBRETTO_WORKFLOW_BRAND] = true;
+    readonly name: string;
     private readonly handler;
-    constructor(handler: LibrettoWorkflowHandler<Input, Output, S>);
+    constructor(name: string, handler: LibrettoWorkflowHandler<Input, Output, S>);
     run(ctx: LibrettoWorkflowContext<S>, input: Input): Promise<Output>;
 }
-declare function workflow<Input = unknown, Output = unknown, S = {}>(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, S = {}>(name: string, handler: LibrettoWorkflowHandler<Input, Output, S>): LibrettoWorkflow<Input, Output, S>;
 
-export { LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, type LibrettoWorkflowContext, type LibrettoWorkflowHandler, workflow };
+export { type ExportedLibrettoWorkflow, LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, type LibrettoWorkflowContext, type LibrettoWorkflowHandler, getWorkflowFromModuleExports, getWorkflowsFromModuleExports, isLibrettoWorkflow, workflow };

package/dist/shared/workflow/workflow.js

@@ -1,19 +1,66 @@
 const LIBRETTO_WORKFLOW_BRAND = /* @__PURE__ */ Symbol.for("libretto.workflow");
 class LibrettoWorkflow {
   [LIBRETTO_WORKFLOW_BRAND] = true;
+  name;
   handler;
-  constructor(handler) {
+  constructor(name, handler) {
+    this.name = name;
     this.handler = handler;
   }
   async run(ctx, input) {
     return this.handler(ctx, input);
   }
 }
-function workflow(handler) {
-  return new LibrettoWorkflow(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.2",
+  "version": "0.5.3-experimental.0",
   "description": "AI-powered browser automation library and CLI built on Playwright",
   "license": "MIT",
   "repository": {
@@ -36,11 +36,9 @@
     "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": {
@@ -69,8 +67,13 @@
     "@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",

package/scripts/check-skills-sync.mjs

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 import { compareSkillDirs, SKILL_DIRS } from "./skills-libretto.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const repoRoot = join(__dirname, "..");
+const repoRoot = join(__dirname, "..", "..", "..");
 const result = compareSkillDirs(repoRoot);
 
 if (result.ok) {

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/skills-libretto.mjs

@@ -11,7 +11,7 @@ import {
 import { relative, resolve, join } from "node:path";
 
 export const SKILL_DIRS = [
-  "skills/libretto",
+  "packages/libretto/skills/libretto",
   ".agents/skills/libretto",
   ".claude/skills/libretto",
 ];

package/scripts/sync-skills.mjs

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 import { SKILL_DIRS, syncRepoSkills } from "./skills-libretto.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const repoRoot = join(__dirname, "..");
+const repoRoot = join(__dirname, "..", "..", "..");
 
 syncRepoSkills(repoRoot);
 console.log(`libretto: synced skill mirrors across ${SKILL_DIRS.join(", ")}`);

package/skills/libretto/SKILL.md

@@ -83,6 +83,7 @@ npx libretto snapshot \
 
 - Use `exec` for focused inspection and short-lived interaction experiments.
 - Use `exec` to validate selectors, inspect data, or prototype a step before you encode it in the workflow file.
+- Use `exec -` to run multi-line scripts from stdin, especially when the code is too long or complex for a command line argument.
 - Available globals: `page`, `context`, `browser`, `state`, `fetch`, `Buffer`.
 - Let failures throw. Do not hide `exec` failures with `try/catch` or `.catch()`.
 - Do not run multiple `exec` commands in parallel.
@@ -91,6 +92,7 @@ npx libretto snapshot \
 npx libretto exec "return await page.url()"
 npx libretto exec "return await page.locator('button').count()"
 npx libretto exec "await page.locator('button:has-text(\"Continue\")').click()"
+echo "return await page.url()" | npx libretto exec - --session debug-example
 ```
 
 ### `pages`
@@ -113,8 +115,8 @@ npx libretto exec --session debug-example --page <page-id> "return await page.ur
 - Re-run the same workflow after each fix to verify the browser behavior end to end.
 
 ```bash
-npx libretto run ./integration.ts main --headless --params '{"status":"open"}'
-npx libretto run ./integration.ts main --auth-profile app.example.com
+npx libretto run ./integration.ts workflowName --headless --params '{"status":"open"}'
+npx libretto run ./integration.ts workflowName --auth-profile app.example.com
 ```
 
 ### `resume`

package/skills/libretto/references/code-generation-rules.md

@@ -6,7 +6,7 @@ Follow the user's existing codebase conventions, abstractions, and patterns when
 
 ## Workflow File Structure
 
-Generated files must export a `workflow()` instance so they can be run via `npx libretto run <file> <exportName>`. Import `workflow` and its types from `"libretto"`:
+Generated files must export a `workflow()` instance so they can be run via `npx libretto run <file> <workflowName>`. Import `workflow` and its types from `"libretto"`:
 
 ```typescript
 import { workflow, pause, type LibrettoWorkflowContext } from "libretto";
@@ -23,7 +23,8 @@ type Output = {
 };
 
 export const myWorkflow = workflow<Input, Output>(
-  async (ctx, input): Promise<Output> => {
+  "myWorkflow",
+  async (ctx: LibrettoWorkflowContext, input): Promise<Output> => {
     const { session, page, logger } = ctx;
 
     logger.info("workflow-start", { session, query: input.query });
@@ -37,8 +38,8 @@ export const myWorkflow = workflow<Input, Output>(
 
 Key points:
 
-- The named export (e.g., `myWorkflow`) is what you pass as the second arg to `npx libretto run ./file.ts myWorkflow`
-- `workflow(handler)` returns a branded workflow object with a `.run(ctx, input)` method. The CLI expects that contract.
+- `workflow(name, handler)` takes a unique workflow name and returns the workflow object that Libretto can run.
+- `npx libretto run ./file.ts myWorkflow` resolves `myWorkflow` from the workflows exported by `./file.ts`, so export or re-export the workflow from that file directly or through a `workflows` object, and make sure the run argument matches the name passed to `workflow("myWorkflow", ...)`.
 - `ctx` provides `session`, `page`, `logger`, and `services` (generic, default `{}`)
 - `input` comes from `--params '{"query":"foo"}'` or `--params-file params.json` on the CLI
 - Use `await pause(ctx.session)` (or `await pause(session)`) to pause the workflow for debugging. It is a no-op in production.
@@ -57,6 +58,7 @@ import { type Transaction } from "./db";
 type MyServices = { tx?: Transaction };
 
 export const myWorkflow = workflow<Input, Output, MyServices>(
+  "myWorkflow",
   async (ctx, input) => {
     if (ctx.services.tx) {
       await ctx.services.tx.insert(/* ... */);

package/src/cli/commands/execution.ts

@@ -605,9 +605,10 @@ async function runIntegrationFromFile(
   );
   const payload = JSON.stringify({
     integrationPath: args.integrationPath,
-    exportName: args.exportName,
+    workflowName: args.workflowName,
     session: args.session,
     params: args.params,
+    credentials: args.credentials,
     headless: args.headless,
     visualize: args.visualize,
     authProfileDomain: args.authProfileDomain,
@@ -656,11 +657,20 @@ async function runIntegrationFromFile(
   console.log("Integration completed.");
 }
 
+function readStdinSync(): string | null {
+  if (process.stdin.isTTY === true) return null;
+  try {
+    const content = readFileSync(0, "utf8");
+    return content.trim().length > 0 ? content : null;
+  } catch {
+    return null;
+  }
+}
+
 export const execInput = SimpleCLI.input({
   positionals: [
-    SimpleCLI.positional("codeParts", z.array(z.string()).default([]), {
+    SimpleCLI.positional("code", z.string().optional(), {
       help: "Playwright TypeScript code to execute",
-      variadic: true,
     }),
   ],
   named: {
@@ -671,8 +681,8 @@ export const execInput = SimpleCLI.input({
     page: pageOption(),
   },
 }).refine(
-  (input) => input.codeParts.length > 0,
-  `Usage: libretto exec <code> [--session <name>] [--visualize]`,
+  (input) => input.code !== undefined,
+  `Usage: libretto exec <code|-> [--session <name>] [--visualize]\n       echo '<code>' | libretto exec - [--session <name>] [--visualize]`,
 );
 
 export const execCommand = SimpleCLI.command({
@@ -681,8 +691,15 @@ export const execCommand = SimpleCLI.command({
   .input(execInput)
   .use(withRequiredSession())
   .handle(async ({ input, ctx }) => {
+    const code = input.code!;
+    const codeFromArgsOrStdin = code === "-" ? readStdinSync() : code;
+    if (codeFromArgsOrStdin === null) {
+      throw new Error(
+        "Missing stdin input for `exec -`. Pipe Playwright code into stdin.",
+      );
+    }
     await runExec(
-      input.codeParts.join(" "),
+      codeFromArgsOrStdin,
       ctx.session,
       ctx.logger,
       input.visualize,
@@ -690,15 +707,15 @@ export const execCommand = SimpleCLI.command({
     );
   });
 
-const runUsage = `Usage: libretto run <integrationFile> <integrationExport> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless] [--no-visualize] [--viewport WxH]`;
+const runUsage = `Usage: libretto run <integrationFile> <workflowName> [--params <json> | --params-file <path>] [--credentials <json>] [--tsconfig <path>] [--headed|--headless] [--no-visualize] [--viewport WxH]`;
 
 export const runInput = SimpleCLI.input({
   positionals: [
     SimpleCLI.positional("integrationFile", z.string().optional(), {
       help: "Path to the integration file",
     }),
-    SimpleCLI.positional("integrationExport", z.string().optional(), {
-      help: "Named workflow export to run",
+    SimpleCLI.positional("workflowName", z.string().optional(), {
+      help: "Workflow name to run (from workflow(name, handler))",
     }),
   ],
   named: {
@@ -710,6 +727,9 @@ export const runInput = SimpleCLI.input({
       name: "params-file",
       help: "Path to a JSON params file",
     }),
+    credentials: SimpleCLI.option(z.string().optional(), {
+      help: "Inline JSON credentials passed to ctx.credentials",
+    }),
     tsconfig: SimpleCLI.option(z.string().optional(), {
       help: "Path to a tsconfig used for workflow module resolution",
     }),
@@ -729,7 +749,7 @@ export const runInput = SimpleCLI.input({
   },
 })
   .refine(
-    (input) => Boolean(input.integrationFile && input.integrationExport),
+    (input) => Boolean(input.integrationFile && input.workflowName),
     runUsage,
   )
   .refine(
@@ -772,6 +792,13 @@ export const runCommand = SimpleCLI.command({
     assertSessionAvailableForStart(ctx.session, ctx.logger);
 
     const params = resolveRunParams(input.params, input.paramsFile);
+    const rawCredentials = input.credentials
+      ? parseJsonArg("--credentials", input.credentials)
+      : undefined;
+    if (rawCredentials !== undefined && (typeof rawCredentials !== "object" || rawCredentials === null || Array.isArray(rawCredentials))) {
+      throw new Error("--credentials must be a JSON object (e.g., '{\"key\": \"value\"}').");
+    }
+    const credentials = rawCredentials as Record<string, unknown> | undefined;
     const headlessMode = input.headed
       ? false
       : input.headless
@@ -786,9 +813,10 @@ export const runCommand = SimpleCLI.command({
     await runIntegrationFromFile(
       {
         integrationPath: input.integrationFile!,
-        exportName: input.integrationExport!,
+        workflowName: input.workflowName!,
         session: ctx.session,
         params,
+        credentials,
         tsconfigPath: input.tsconfig,
         headless: headlessMode ?? false,
         visualize,

package/src/cli/framework/simple-cli.ts

@@ -579,6 +579,11 @@ export class SimpleCLIApp {
         break;
       }
 
+      if (arg === "-") {
+        positionals.push(arg);
+        continue;
+      }
+
       if (arg.startsWith("--")) {
         const [rawName, inlineValue] = splitNamedArg(arg.slice(2));
         const namedEntry = namedSpecs.get(rawName);

package/src/cli/workers/run-integration-runtime.ts

@@ -5,8 +5,11 @@ import { cwd } from "node:process";
 import { isAbsolute, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import {
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
   instrumentContext,
   launchBrowser,
+  type ExportedLibrettoWorkflow,
   type LibrettoWorkflowContext,
 } from "../../index.js";
 import type { LoggerApi } from "../../shared/logger/index.js";
@@ -25,9 +28,7 @@ import {
 import { installSessionTelemetry } from "../core/session-telemetry.js";
 import type { RunIntegrationWorkerRequest } from "./run-integration-worker-protocol.js";
 
-const LIBRETTO_WORKFLOW_BRAND = Symbol.for("libretto.workflow");
-
-type LoadedLibrettoWorkflow = {
+type LoadedLibrettoWorkflow = ExportedLibrettoWorkflow & {
   run: (ctx: LibrettoWorkflowContext, input: unknown) => Promise<unknown>;
 };
 
@@ -108,17 +109,6 @@ async function waitForFailureSessionRelease(args: {
   }
 }
 
-function isLoadedLibrettoWorkflow(
-  value: unknown,
-): value is LoadedLibrettoWorkflow {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value as Record<PropertyKey, unknown>;
-  return (
-    candidate[LIBRETTO_WORKFLOW_BRAND] === true &&
-    typeof candidate.run === "function"
-  );
-}
-
 function resolveLocalAuthProfilePath(domain: string): string {
   return getProfilePath(normalizeDomain(domain));
 }
@@ -149,9 +139,9 @@ function getAbsoluteIntegrationPath(integrationPath: string): string {
   return absolutePath;
 }
 
-async function loadWorkflowExport(
+async function loadWorkflowByName(
   absolutePath: string,
-  exportName: string,
+  workflowName: string,
 ): Promise<LoadedLibrettoWorkflow> {
   let loadedModule: Record<string, unknown>;
   try {
@@ -167,42 +157,23 @@ async function loadWorkflowExport(
     );
   }
 
-  const targetExport = loadedModule[exportName];
-  if (!targetExport) {
-    const availableExports = Object.keys(loadedModule);
-    const detail =
-      availableExports.length > 0
-        ? ` Available exports: ${availableExports.join(", ")}`
-        : " The module has no exports.";
-    throw new Error(
-      `Export "${exportName}" was not found in ${absolutePath}.${detail}`,
-    );
+  const workflow = getWorkflowFromModuleExports(loadedModule, workflowName);
+  if (workflow) {
+    return workflow as LoadedLibrettoWorkflow;
   }
 
-  if (!isLoadedLibrettoWorkflow(targetExport)) {
-    throw new Error(
-      [
-        `Export "${exportName}" in ${absolutePath} is not a valid Libretto workflow.`,
-        "",
-        'A workflow must be created using the workflow() function from "libretto":',
-        "",
-        '  import { workflow } from "libretto";',
-        "",
-        `  export const ${exportName} = workflow<InputType, OutputType>(`,
-        "    async (ctx, input) => {",
-        "      // ctx.session  — libretto session name",
-        "      // ctx.page     — Playwright Page instance",
-        "      // ctx.logger   — MinimalLogger",
-        "      // ctx.services — injected dependencies (generic, default {})",
-        "      // input        — JSON-serializable input matching InputType",
-        "      return output; // must match OutputType",
-        "    },",
-        "  );",
-      ].join("\n"),
-    );
-  }
+  const availableWorkflows = getWorkflowsFromModuleExports(loadedModule).map(
+    (candidate) => candidate.name,
+  );
+
+  const detail =
+    availableWorkflows.length > 0
+      ? ` Available workflows: ${availableWorkflows.join(", ")}`
+      : ' No workflows found in this file. Export a workflow() instance from "libretto" directly or via `export const workflows = { ... }`.';
 
-  return targetExport;
+  throw new Error(
+    `Workflow "${workflowName}" not found in ${absolutePath}.${detail}`,
+  );
 }
 
 export async function installHeadedWorkflowVisualization(args: {
@@ -224,7 +195,7 @@ async function runIntegrationInternal(
 ): Promise<RunIntegrationOutcome> {
   const { logger } = options;
   const absolutePath = getAbsoluteIntegrationPath(args.integrationPath);
-  const workflow = await loadWorkflowExport(absolutePath, args.exportName);
+  const workflow = await loadWorkflowByName(absolutePath, args.workflowName);
   const signalPaths = getPauseSignalPaths(args.session);
   await removeSignalIfExists(signalPaths.pausedSignalPath);
   await removeSignalIfExists(signalPaths.resumeSignalPath);
@@ -233,12 +204,12 @@ async function runIntegrationInternal(
   const restoreStdout = mirrorStdoutToFile(signalPaths.outputSignalPath);
 
   console.log(
-    `Running integration "${args.exportName}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`,
+    `Running workflow "${args.workflowName}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`,
   );
 
   const integrationLogger = logger.withScope("integration-run", {
     integrationPath: absolutePath,
-    integrationExport: args.exportName,
+    workflowName: args.workflowName,
     session: args.session,
   });
 
@@ -287,6 +258,7 @@ async function runIntegrationInternal(
     logger: integrationLogger,
     page: browserSession.page,
     services: {},
+    credentials: args.credentials,
   };
 
   try {

package/src/cli/workers/run-integration-worker-protocol.ts

@@ -2,9 +2,10 @@ import { z } from "zod";
 
 export const RunIntegrationWorkerRequestSchema = z.object({
   integrationPath: z.string().min(1),
-  exportName: z.string().min(1),
+  workflowName: z.string().min(1),
   session: z.string().min(1),
   params: z.unknown(),
+  credentials: z.record(z.string(), z.unknown()).optional(),
   headless: z.boolean(),
   visualize: z.boolean().default(true),
   authProfileDomain: z.string().optional(),

package/src/index.ts

@@ -102,9 +102,13 @@ export {
 
 // Workflow helpers
 export {
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
+  isLibrettoWorkflow,
   LibrettoWorkflow,
   LIBRETTO_WORKFLOW_BRAND,
   workflow,
+  type ExportedLibrettoWorkflow,
   type LibrettoWorkflowContext,
   type LibrettoWorkflowHandler,
 } from "./shared/workflow/workflow.js";

package/src/shared/workflow/workflow.ts

@@ -8,6 +8,7 @@ export type LibrettoWorkflowContext<S = {}> = {
   page: Page;
   logger: MinimalLogger;
   services: S;
+  credentials?: Record<string, unknown>;
 };
 
 export type LibrettoWorkflowHandler<
@@ -18,9 +19,14 @@ export type LibrettoWorkflowHandler<
 
 export class LibrettoWorkflow<Input = unknown, Output = unknown, S = {}> {
   public readonly [LIBRETTO_WORKFLOW_BRAND] = true;
+  public readonly name: string;
   private readonly handler: LibrettoWorkflowHandler<Input, Output, S>;
 
-  constructor(handler: LibrettoWorkflowHandler<Input, Output, S>) {
+  constructor(
+    name: string,
+    handler: LibrettoWorkflowHandler<Input, Output, S>,
+  ) {
+    this.name = name;
     this.handler = handler;
   }
 
@@ -29,8 +35,88 @@ export class LibrettoWorkflow<Input = unknown, Output = unknown, S = {}> {
   }
 }
 
+export type ExportedLibrettoWorkflow = {
+  readonly [LIBRETTO_WORKFLOW_BRAND]: true;
+  readonly name: string;
+  run: (ctx: LibrettoWorkflowContext, input: unknown) => Promise<unknown>;
+};
+
+type WorkflowModuleExports = Record<string, unknown>;
+
+// Use the workflow brand instead of `instanceof` so imported workflows are
+// still recognized after loading the integration module dynamically.
+export function isLibrettoWorkflow(
+  value: unknown,
+): value is ExportedLibrettoWorkflow {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Record<PropertyKey, unknown>;
+  return (
+    candidate[LIBRETTO_WORKFLOW_BRAND] === true &&
+    typeof candidate.name === "string" &&
+    typeof candidate.run === "function"
+  );
+}
+
+function addWorkflowOrThrow(
+  workflowsByName: Map<string, ExportedLibrettoWorkflow>,
+  value: unknown,
+): void {
+  if (!isLibrettoWorkflow(value)) return;
+
+  // Re-exporting the same workflow object is fine, but two distinct workflow
+  // instances cannot claim the same runtime name.
+  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);
+}
+
+export function getWorkflowsFromModuleExports(
+  moduleExports: WorkflowModuleExports,
+): ExportedLibrettoWorkflow[] {
+  const workflowsByName = new Map<string, ExportedLibrettoWorkflow>();
+
+  for (const [exportName, value] of Object.entries(moduleExports)) {
+    if (exportName === "workflows" && value && typeof value === "object") {
+      // Support both `export const workflows = workflow(...)` and
+      // `export const workflows = { myWorkflow }`.
+      if (isLibrettoWorkflow(value)) {
+        addWorkflowOrThrow(workflowsByName, value);
+      } else {
+        for (const nestedValue of Object.values(
+          value as Record<string, unknown>,
+        )) {
+          addWorkflowOrThrow(workflowsByName, nestedValue);
+        }
+      }
+      continue;
+    }
+
+    addWorkflowOrThrow(workflowsByName, value);
+  }
+
+  return [...workflowsByName.values()];
+}
+
+export function getWorkflowFromModuleExports(
+  moduleExports: WorkflowModuleExports,
+  workflowName: string,
+): ExportedLibrettoWorkflow | null {
+  for (const workflow of getWorkflowsFromModuleExports(moduleExports)) {
+    if (workflow.name === workflowName) {
+      return workflow;
+    }
+  }
+  return null;
+}
+
 export function workflow<Input = unknown, Output = unknown, S = {}>(
+  name: string,
   handler: LibrettoWorkflowHandler<Input, Output, S>,
 ): LibrettoWorkflow<Input, Output, S> {
-  return new LibrettoWorkflow(handler);
+  return new LibrettoWorkflow(name, handler);
 }

package/scripts/prepare-release.sh

@@ -1,97 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-usage() {
-  cat <<'EOF'
-Usage: scripts/prepare-release.sh [patch|minor|major]
-
-Creates a release PR branch from main, bumps package.json, pushes the branch,
-and opens a pull request targeting main.
-EOF
-}
-
-bump="${1:-patch}"
-
-case "$bump" in
-  patch|minor|major)
-    ;;
-  -h|--help|help)
-    usage
-    exit 0
-    ;;
-  *)
-    echo "Invalid bump type: $bump" >&2
-    usage >&2
-    exit 1
-    ;;
-esac
-
-if ! command -v gh >/dev/null 2>&1; then
-  echo "gh CLI is required." >&2
-  exit 1
-fi
-
-if [ -n "$(git status --porcelain)" ]; then
-  echo "Working tree must be clean before preparing a release." >&2
-  exit 1
-fi
-
-current_branch="$(git branch --show-current)"
-if [ "$current_branch" != "main" ]; then
-  echo "Switching from $current_branch to main."
-fi
-
-git fetch origin
-git checkout main
-git pull --ff-only origin main
-
-pnpm install --frozen-lockfile
-pnpm type-check
-pnpm test
-
-current_version="$(node -p "require('./package.json').version")"
-next_version="$(node -e '
-const [major, minor, patch] = process.argv[1].split(".").map(Number)
-const bump = process.argv[2]
-
-let next
-if (bump === "major") next = [major + 1, 0, 0]
-else if (bump === "minor") next = [major, minor + 1, 0]
-else next = [major, minor, patch + 1]
-
-process.stdout.write(next.join("."))
-' "$current_version" "$bump")"
-branch_name="tk-release-v${next_version}"
-
-if git show-ref --verify --quiet "refs/heads/${branch_name}"; then
-  echo "Local branch ${branch_name} already exists." >&2
-  exit 1
-fi
-
-if git ls-remote --exit-code --heads origin "${branch_name}" >/dev/null 2>&1; then
-  echo "Remote branch ${branch_name} already exists." >&2
-  exit 1
-fi
-
-npm version "$next_version" --no-git-tag-version >/dev/null
-
-git checkout -b "$branch_name"
-git add package.json
-git commit -m "release: v${next_version}"
-git push -u origin "$branch_name"
-
-gh pr create \
-  --base main \
-  --head "$branch_name" \
-  --title "release: v${next_version}" \
-  --body "$(cat <<EOF
-## Summary
-
-- release libretto v${next_version}
-
-## Verification
-
-- pnpm type-check
-- pnpm test
-EOF
-)"