libretto 0.2.7 → 0.3.1

package/dist/cli/cli.js

@@ -12,9 +12,11 @@ import {
   ensureLibrettoSetup
 } from "./core/context.js";
 import {
-  SESSION_DEFAULT,
+  listSessionsWithStateFile,
   validateSessionName
 } from "./core/session.js";
+const AUTO_SESSION_COMMANDS = /* @__PURE__ */ new Set(["open", "run"]);
+const SESSION_OPTIONAL_COMMANDS = /* @__PURE__ */ new Set(["help", "--help", "-h", "init", "ai"]);
 const CLI_COMMANDS = /* @__PURE__ */ new Set([
   "open",
   "run",
@@ -36,10 +38,10 @@ function printUsage() {
   console.log(`Usage: libretto-cli <command> [--session <name>]
 
 Commands:
-  init [--skip-browsers] Initialize libretto (copy skills, install browsers)
+  init [--skip-browsers] Initialize libretto (install browsers, check AI setup)
   open <url> [--headless] Launch browser and open URL (headed by default)
                           Automatically loads saved profile if available
-  run <integrationFile> <integrationExport> [--params <json> | --params-file <path>] [--headed|--headless]  Run an exported Libretto workflow from a file
+  run <integrationFile> <integrationExport> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless]  Run an exported Libretto workflow from a file
   ai configure [preset] [-- <command prefix...>]  Configure AI runtime for analysis commands
   save <url|domain>       Save current browser session (cookies, localStorage, etc.)
   exec <code> [--visualize]  Execute Playwright typescript code (--visualize enables ghost cursor + highlight)
@@ -51,7 +53,9 @@ Commands:
   close [--all] [--force]  Close the browser for the session, or all tracked sessions with --all
 
 Options:
-  --session <name>        Use a named session (default: "default")
+  --session <name>        Use a named session
+                          If omitted for open/run, a session id is auto-generated
+                          All other stateful commands require --session
                           Built-in sessions: default, dev-server, browser-agent
 
 Examples:
@@ -107,55 +111,116 @@ function filterSessionArgs(args) {
 }
 function parseSessionForLog(rawArgs) {
   const idx = rawArgs.indexOf("--session");
-  if (idx < 0) return SESSION_DEFAULT;
+  if (idx < 0) return null;
   const value = rawArgs[idx + 1];
   if (!value || value.startsWith("--") || CLI_COMMANDS.has(value)) {
-    return SESSION_DEFAULT;
+    return null;
   }
   try {
     validateSessionName(value);
     return value;
   } catch {
-    return SESSION_DEFAULT;
+    return null;
   }
 }
-function validateLegacySessionArg(rawArgs) {
-  const idx = rawArgs.indexOf("--session");
-  if (idx < 0) return;
-  const value = rawArgs[idx + 1];
-  if (!value || value.startsWith("--") || CLI_COMMANDS.has(value)) {
-    throw new Error(
-      "Usage: libretto-cli <command> [--session <name>]\nMissing or invalid --session value."
-    );
+function hasExplicitSession(rawArgs) {
+  return rawArgs.includes("--session");
+}
+function randomSessionId() {
+  const digits = Math.floor(Math.random() * 1e4).toString().padStart(4, "0");
+  return `ses-${digits}`;
+}
+function generateSessionId() {
+  const activeSessions = new Set(listSessionsWithStateFile());
+  for (let attempt = 0; attempt < 1e4; attempt += 1) {
+    const candidate = randomSessionId();
+    if (!activeSessions.has(candidate)) {
+      return candidate;
+    }
   }
-  validateSessionName(value);
+  throw new Error(
+    "Could not generate an available session id. Close an existing session and try again."
+  );
 }
-function initializeLogger(rawArgs) {
-  const sessionForLog = parseSessionForLog(rawArgs);
-  const logger = createLoggerForSession(sessionForLog);
-  logger.info("cli-start", {
-    args: rawArgs,
-    cwd: process.cwd(),
-    session: sessionForLog
-  });
-  return logger;
+function hasExecCodeArg(filteredArgs) {
+  for (let i = 1; i < filteredArgs.length; i += 1) {
+    const token = filteredArgs[i];
+    if (!token) continue;
+    if (token === "--") {
+      return filteredArgs.length > i + 1;
+    }
+    if (token === "--visualize") {
+      continue;
+    }
+    if (token === "--page") {
+      const maybeValue = filteredArgs[i + 1];
+      if (maybeValue && !maybeValue.startsWith("--")) {
+        i += 1;
+      }
+      continue;
+    }
+    if (token.startsWith("--page=")) {
+      continue;
+    }
+    if (token.startsWith("-")) {
+      continue;
+    }
+    return true;
+  }
+  return false;
 }
-async function withCliLogger(rawArgs, run) {
-  const logger = initializeLogger(rawArgs);
-  try {
-    return await run(logger);
-  } finally {
-    await closeLogger(logger);
+function commandNeedsSession(command, rawArgs, filteredArgs) {
+  if (AUTO_SESSION_COMMANDS.has(command)) return false;
+  if (SESSION_OPTIONAL_COMMANDS.has(command)) return false;
+  if (command === "close" && rawArgs.includes("--all")) return false;
+  if (command === "close" && rawArgs.includes("--force")) return false;
+  if (command === "exec" && !hasExecCodeArg(filteredArgs)) return false;
+  if (command === "save" && filteredArgs.length <= 1) return false;
+  if (!CLI_COMMANDS.has(command)) return false;
+  return true;
+}
+function resolveSessionArgs(rawArgs) {
+  const filtered = filterSessionArgs(rawArgs);
+  const command = filtered[0];
+  const explicitSession = parseSessionForLog(rawArgs);
+  if (!command) {
+    return {
+      args: rawArgs,
+      generatedSession: null,
+      resolvedSession: explicitSession
+    };
+  }
+  if (hasExplicitSession(rawArgs)) {
+    return {
+      args: rawArgs,
+      generatedSession: null,
+      resolvedSession: explicitSession
+    };
+  }
+  if (!AUTO_SESSION_COMMANDS.has(command)) {
+    return {
+      args: rawArgs,
+      generatedSession: null,
+      resolvedSession: null
+    };
   }
+  const generatedSession = generateSessionId();
+  return {
+    args: [...rawArgs, "--session", generatedSession],
+    generatedSession,
+    resolvedSession: generatedSession
+  };
 }
 function createParser(logger) {
   let parser = yargs(hideBin(process.argv)).scriptName("libretto-cli").parserConfiguration({ "populate--": true }).option("session", {
     type: "string",
-    default: SESSION_DEFAULT,
     describe: "Use a named session",
-    global: true
+    global: true,
+    requiresArg: true
   }).middleware((argv) => {
-    validateSessionName(String(argv.session));
+    if (argv.session !== void 0) {
+      validateSessionName(String(argv.session));
+    }
   }).exitProcess(false).help(false).version(false).fail((msg, err) => {
     if (err) throw err;
     throw new Error(msg || "Command failed");
@@ -175,33 +240,57 @@ function createParser(logger) {
 async function runLibrettoCLI() {
   const rawArgs = process.argv.slice(2);
   let exitCode = 0;
+  let effectiveArgs = rawArgs;
+  let generatedSession = null;
+  let resolvedSession = null;
+  ({
+    args: effectiveArgs,
+    generatedSession,
+    resolvedSession
+  } = resolveSessionArgs(rawArgs));
   ensureLibrettoSetup();
-  await withCliLogger(rawArgs, async (logger) => {
-    try {
-      validateLegacySessionArg(rawArgs);
-      const args = filterSessionArgs(rawArgs);
-      const command = args[0];
-      if (!command || command === "--help" || command === "-h" || command === "help") {
-        printUsage();
-        return;
-      }
-      if (!CLI_COMMANDS.has(command)) {
-        console.error(`Unknown command: ${command}
+  const args = filterSessionArgs(effectiveArgs);
+  const command = args[0];
+  if (!command || command === "--help" || command === "-h" || command === "help") {
+    printUsage();
+    process.exit(exitCode);
+    return;
+  }
+  if (!CLI_COMMANDS.has(command)) {
+    console.error(`Unknown command: ${command}
 `);
-        printUsage();
-        exitCode = 1;
-        return;
-      }
-      const parser = createParser(logger);
-      logger.info("cli-command", { command, args });
-      await parser.parseAsync();
-    } catch (err) {
-      logger.error("cli-error", { error: err, args: rawArgs });
-      const message = err instanceof Error ? err.message : String(err);
-      console.error(message);
-      exitCode = 1;
-    }
-  });
+    printUsage();
+    process.exit(1);
+    return;
+  }
+  if (!hasExplicitSession(effectiveArgs) && commandNeedsSession(command, effectiveArgs, args)) {
+    console.error(
+      [
+        `Missing required --session for "${command}".`,
+        "Pass --session <name>, or use open/run without --session to auto-create one."
+      ].join("\n")
+    );
+    process.exit(1);
+    return;
+  }
+  const sessionForLogger = resolvedSession ?? "cli";
+  const logger = createLoggerForSession(sessionForLogger);
+  try {
+    const parser = createParser(logger);
+    await parser.parseAsync(effectiveArgs);
+  } catch (err) {
+    logger.error("cli-error", {
+      error: err,
+      args: rawArgs,
+      effectiveArgs,
+      generatedSession
+    });
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(message);
+    exitCode = 1;
+  } finally {
+    await closeLogger(logger);
+  }
   process.exit(exitCode);
 }
 export {

package/dist/cli/commands/execution.js

@@ -21,6 +21,8 @@ import {
   wrapPageForActionLogging
 } from "../core/telemetry.js";
 const stripTypeScriptTypes = moduleBuiltin.stripTypeScriptTypes;
+const require2 = moduleBuiltin.createRequire(import.meta.url);
+const tsxCliPath = require2.resolve("tsx/cli");
 function withSuppressedStripTypeScriptWarning(action) {
   const mutableProcess = process;
   const originalEmitWarning = mutableProcess.emitWarning;
@@ -209,20 +211,25 @@ function readJsonFileIfExists(path) {
     return null;
   }
 }
-function readFailureMessage(path) {
+function readFailureSignal(path) {
   const raw = readJsonFileIfExists(path);
   if (!raw || typeof raw !== "object") return null;
   const message = raw.message;
-  return typeof message === "string" ? message : null;
+  if (typeof message !== "string") return null;
+  const phase = raw.phase;
+  return {
+    message,
+    phase: phase === "setup" || phase === "workflow" ? phase : void 0
+  };
 }
-async function waitForFailureMessage(path, timeoutMs = 1e3) {
+async function waitForFailureSignal(path, timeoutMs = 1e3) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
-    const message = readFailureMessage(path);
-    if (message) return message;
+    const failure = readFailureSignal(path);
+    if (failure) return failure;
     await new Promise((resolveWait) => setTimeout(resolveWait, 25));
   }
-  return readFailureMessage(path);
+  return readFailureSignal(path);
 }
 function streamOutputSince(path, offset) {
   if (!existsSync(path)) return offset;
@@ -248,8 +255,12 @@ async function waitForWorkflowOutcome(args) {
     outputOffset = streamOutputSince(signalPaths.outputSignalPath, outputOffset);
     if (existsSync(signalPaths.failedSignalPath)) {
       outputOffset = streamOutputSince(signalPaths.outputSignalPath, outputOffset);
-      const message = await waitForFailureMessage(signalPaths.failedSignalPath);
-      return { status: "failed", message: message ?? void 0 };
+      const failure = await waitForFailureSignal(signalPaths.failedSignalPath);
+      return {
+        status: "failed",
+        message: failure?.message,
+        failurePhase: failure?.phase
+      };
     }
     if (existsSync(signalPaths.completedSignalPath)) {
       outputOffset = streamOutputSince(signalPaths.outputSignalPath, outputOffset);
@@ -339,8 +350,20 @@ async function runIntegrationFromFile(args, logger) {
   const workerEntryPath = fileURLToPath(
     new URL("../workers/run-integration-worker.js", import.meta.url)
   );
-  const payload = JSON.stringify(args);
-  const worker = spawn(process.execPath, [workerEntryPath, payload], {
+  const payload = JSON.stringify({
+    integrationPath: args.integrationPath,
+    exportName: args.exportName,
+    session: args.session,
+    params: args.params,
+    headless: args.headless,
+    authProfileDomain: args.authProfileDomain
+  });
+  const worker = spawn(process.execPath, [
+    tsxCliPath,
+    ...args.tsconfigPath ? ["--tsconfig", args.tsconfigPath] : [],
+    workerEntryPath,
+    payload
+  ], {
     detached: true,
     stdio: "ignore",
     env: process.env
@@ -357,10 +380,14 @@ async function runIntegrationFromFile(args, logger) {
   }
   if (outcome.status === "failed") {
     setSessionStatus(args.session, "failed", logger);
-    throw new Error(
-      `${outcome.message ?? "Workflow failed during run."}
+    const message = outcome.message ?? "Workflow failed during run.";
+    if (outcome.failurePhase === "workflow") {
+      throw new Error(
+        `${message}
 Browser is still open. You can use \`exec\` to inspect it. Call \`run\` to re-run the workflow.`
-    );
+      );
+    }
+    throw new Error(message);
   }
   if (outcome.status === "exited") {
     setSessionStatus(args.session, "exited", logger);
@@ -394,9 +421,9 @@ function registerExecutionCommands(yargs, logger) {
   ).command(
     "run [integrationFile] [integrationExport]",
     "Run an exported Libretto workflow from a file",
-    (cmd) => cmd.option("params", { type: "string" }).option("params-file", { type: "string" }).option("headed", { type: "boolean", default: false }).option("headless", { type: "boolean", default: false }).option("auth-profile", { type: "string", describe: "Domain for local auth profile (e.g. apps.example.com)" }),
+    (cmd) => cmd.option("params", { type: "string" }).option("params-file", { type: "string" }).option("tsconfig", { type: "string" }).option("headed", { type: "boolean", default: false }).option("headless", { type: "boolean", default: false }).option("auth-profile", { type: "string", describe: "Domain for local auth profile (e.g. apps.example.com)" }),
     async (argv) => {
-      const usage = "Usage: libretto-cli run <integrationFile> <integrationExport> [--params <json> | --params-file <path>] [--headed|--headless]";
+      const usage = "Usage: libretto-cli run <integrationFile> <integrationExport> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless]";
       const integrationPath = argv.integrationFile;
       const exportName = argv.integrationExport;
       const legacyDebug = argv.debug;
@@ -438,13 +465,15 @@ function registerExecutionCommands(yargs, logger) {
       }
       const headlessMode = hasHeadedFlag ? false : hasHeadlessFlag ? true : void 0;
       const authProfileDomain = argv["auth-profile"];
+      const tsconfigPath = argv.tsconfig;
       await runIntegrationFromFile({
         integrationPath,
         exportName,
         session,
         params,
         headless: headlessMode ?? false,
-        authProfileDomain
+        authProfileDomain,
+        tsconfigPath
       }, logger);
     }
   ).command(

package/dist/cli/commands/init.js

@@ -1,36 +1,68 @@
-import { existsSync, mkdirSync, cpSync, readdirSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { accessSync, constants, statSync } from "node:fs";
+import { join, delimiter, extname } from "node:path";
 import { spawnSync } from "node:child_process";
-import { REPO_ROOT } from "../core/context.js";
-function getSkillSourceDir() {
-  const thisDir = dirname(fileURLToPath(import.meta.url));
-  const pkgRoot = join(thisDir, "..", "..", "..");
-  const skillDir = join(pkgRoot, "skill");
-  if (existsSync(skillDir)) return skillDir;
-  const skillsDir = join(pkgRoot, "skills");
-  if (existsSync(skillsDir)) return skillsDir;
-  throw new Error(
-    "Could not find skill/ or skills/ directory in the libretto package."
-  );
+import {
+  AI_CONFIG_PRESETS,
+  AiPresetSchema,
+  formatCommandPrefix,
+  readAiConfig
+} from "../core/ai-config.js";
+const AI_RUNTIME_PRESETS = AiPresetSchema.options;
+function getPresetCommand(preset) {
+  return AI_CONFIG_PRESETS[preset][0] ?? "";
 }
-function copySkills() {
-  const src = getSkillSourceDir();
-  const files = readdirSync(src);
-  if (files.length === 0) {
-    console.log("  No skill files found to copy.");
-    return;
+function isRunnableFile(filePath) {
+  try {
+    const stats = statSync(filePath);
+    if (!stats.isFile()) return false;
+    if (process.platform === "win32") {
+      const pathExt = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
+      const extensions = pathExt.split(";").map((ext) => ext.trim().toUpperCase()).filter(Boolean);
+      const fileExt = extname(filePath).toUpperCase();
+      return extensions.includes(fileExt);
+    }
+    accessSync(filePath, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isCommandDefined(command) {
+  if (!command) return false;
+  if (command.includes("/") || command.includes("\\")) {
+    return isRunnableFile(command);
+  }
+  const pathEnv = process.env.PATH ?? "";
+  if (!pathEnv) return false;
+  const pathEntries = pathEnv.split(delimiter).filter(Boolean);
+  if (process.platform === "win32") {
+    const pathExt = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
+    const extensions = pathExt.split(";").map((ext) => ext.trim()).filter(Boolean);
+    const hasExtension = /\.[^./\\]+$/.test(command);
+    const candidates = hasExtension ? [command] : extensions.map(
+      (ext) => ext.startsWith(".") ? `${command}${ext}` : `${command}.${ext}`
+    );
+    return pathEntries.some(
+      (dir) => candidates.some((candidate) => isRunnableFile(join(dir, candidate)))
+    );
   }
-  const targets = [
-    join(REPO_ROOT, ".agents", "skills", "libretto"),
-    join(REPO_ROOT, ".claude", "skills", "libretto")
-  ];
-  for (const target of targets) {
-    mkdirSync(target, { recursive: true });
-    cpSync(src, target, { recursive: true });
-    console.log(`  \u2713 Copied skill files to ${target}`);
+  return pathEntries.some((dir) => isRunnableFile(join(dir, command)));
+}
+function detectAvailableAiRuntimeCommands() {
+  return AI_RUNTIME_PRESETS.filter(
+    (preset) => isCommandDefined(getPresetCommand(preset))
+  );
+}
+function printAiConfigureCommands(prefix = "    ") {
+  for (const preset of AI_RUNTIME_PRESETS) {
+    console.log(`${prefix}npx libretto ai configure ${preset}`);
   }
 }
+function printDifferentAnalyzerHint(prefix = "    ") {
+  console.log(
+    `${prefix}Use npx libretto ai configure <gemini|claude|codex> to configure a different AI analyzer.`
+  );
+}
 function installBrowsers() {
   console.log("\nInstalling Playwright Chromium...");
   const result = spawnSync("npx", ["playwright", "install", "chromium"], {
@@ -45,21 +77,68 @@ function installBrowsers() {
     );
   }
 }
-function checkSnapshotLLM() {
-  const hasAnyCreds = process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
-  console.log("\nSnapshot LLM configuration:");
-  if (hasAnyCreds) {
-    console.log("  \u2713 LLM credentials detected");
-  } else {
-    console.log("  \u2717 No LLM credentials found.");
-    console.log("    Set one of the following environment variables:");
-    console.log("      GOOGLE_CLOUD_PROJECT  (for Vertex AI / Gemini)");
-    console.log("      ANTHROPIC_API_KEY     (for Claude)");
-    console.log("      OPENAI_API_KEY        (for GPT)");
+function checkAiRuntimeConfiguration() {
+  let config = null;
+  let configReadError = null;
+  try {
+    config = readAiConfig();
+  } catch (error) {
+    configReadError = error instanceof Error ? error.message : String(error);
+  }
+  const availableCommands = detectAvailableAiRuntimeCommands();
+  console.log("\nAI runtime configuration:");
+  console.log(
+    "  Libretto can use your coding agent as a subagent to analyze snapshots and other page signals."
+  );
+  console.log(
+    "  This is optional, but it significantly improves page understanding and debugging performance."
+  );
+  if (configReadError) {
+    console.log(`  \u2717 Could not read AI config: ${configReadError}`);
+    console.log("    Reconfigure with:");
+    printAiConfigureCommands("      ");
+    printDifferentAnalyzerHint("    ");
+    return;
+  }
+  if (config) {
+    const configuredCommand = config.commandPrefix[0];
+    if (!isCommandDefined(configuredCommand)) {
+      console.log(
+        `  \u2717 Configured command not found: ${configuredCommand ?? "(empty)"}`
+      );
+      if (availableCommands.length > 0) {
+        console.log(
+          `    Detected available commands: ${availableCommands.join(", ")}`
+        );
+      } else {
+        console.log(
+          "    No codex, claude, or gemini analyzer command was detected on PATH."
+        );
+      }
+      console.log("    Reconfigure with:");
+      printAiConfigureCommands("      ");
+      printDifferentAnalyzerHint("    ");
+      return;
+    }
     console.log(
-      "    Then configure via: npx libretto ai configure <preset>"
+      `  \u2713 Configured (${config.preset}): ${formatCommandPrefix(config.commandPrefix)}`
     );
+    console.log("    Analysis commands are ready to use.");
+    printDifferentAnalyzerHint("    ");
+    return;
   }
+  console.log("  \u2717 No AI config set.");
+  if (availableCommands.length > 0) {
+    console.log(
+      `    Detected available commands: ${availableCommands.join(", ")}`
+    );
+  } else {
+    console.log("    No codex, claude, or gemini analyzer command was detected on PATH.");
+  }
+  console.log("    Configure one with:");
+  printAiConfigureCommands("      ");
+  printDifferentAnalyzerHint("    ");
+  console.log("    Optionally provide a custom command prefix with '-- ...'.");
 }
 function registerInitCommand(yargs) {
   return yargs.command(
@@ -72,20 +151,12 @@ function registerInitCommand(yargs) {
     }),
     (argv) => {
       console.log("Initializing libretto...\n");
-      console.log("Copying skill files...");
-      try {
-        copySkills();
-      } catch (err) {
-        console.error(
-          `  \u2717 ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
       if (!argv["skip-browsers"]) {
         installBrowsers();
       } else {
         console.log("\nSkipping browser installation (--skip-browsers)");
       }
-      checkSnapshotLLM();
+      checkAiRuntimeConfiguration();
       console.log("\n\u2713 libretto init complete");
     }
   );

package/dist/cli/core/browser.js

@@ -257,6 +257,10 @@ const NETWORK_LOG = '${escapedNetworkLogPath}';
 const ACTIONS_LOG = '${escapedActionsLogPath}';
 mkdirSync(dirname(NETWORK_LOG), { recursive: true });
 
+// tsx/esbuild may emit __name() wrappers in Function#toString output.
+const __name = (target, value) =>
+	Object.defineProperty(target, 'name', { value, configurable: true });
+
 ${installSessionTelemetry.toString()}
 
 function logAction(entry) {

package/dist/cli/core/context.js

@@ -2,9 +2,13 @@ import { Logger, createFileLogSink } from "../../shared/logger/index.js";
 import { spawnSync } from "node:child_process";
 import { cwd } from "node:process";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { validateSessionName } from "./session.js";
 function getRepoRoot() {
+  const override = process.env.LIBRETTO_REPO_ROOT?.trim();
+  if (override) {
+    return resolve(override);
+  }
   const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
     encoding: "utf-8"
   });
@@ -53,11 +57,6 @@ function ensureLibrettoSetup() {
   if (!existsSync(LIBRETTO_GITIGNORE_PATH)) {
     writeFileSync(LIBRETTO_GITIGNORE_PATH, LIBRETTO_GITIGNORE_CONTENT, "utf-8");
   }
-  const agentsSkillsDir = join(REPO_ROOT, ".agents", "skills", "libretto");
-  const claudeSkillsDir = join(REPO_ROOT, ".claude", "skills", "libretto");
-  if (!existsSync(agentsSkillsDir) && !existsSync(claudeSkillsDir)) {
-    console.log("[libretto] Skills not installed. Run 'npx libretto init' to complete setup.");
-  }
 }
 function createLoggerForSession(session) {
   validateSessionName(session);