libretto 0.6.28 → 0.6.30-experimental-runtime-libretto.0

package/dist/cli/commands/execution.js

@@ -6,6 +6,7 @@ import {
   connect,
   disconnectBrowser,
   runClose,
+  resolveWindowPosition,
   resolveViewport
 } from "../core/browser.js";
 import { parseViewportArg } from "./browser.js";
@@ -20,7 +21,9 @@ import {
   writeSessionState
 } from "../core/session.js";
 import { warnIfLibrettoVersionsDiffer } from "../core/skill-version.js";
-import { readLibrettoConfig } from "../core/config.js";
+import {
+  readLibrettoConfig
+} from "../core/config.js";
 import { renderSnapshotDiff } from "../../shared/snapshot/diff-snapshots.js";
 import {
   getProviderStartupTimeoutMs,
@@ -51,6 +54,20 @@ import {
   withRequiredSession
 } from "./shared.js";
 const require2 = moduleBuiltin.createRequire(import.meta.url);
+function createRunBrowserConfig(args) {
+  if (args.providerName) {
+    return {
+      kind: "provider",
+      providerName: args.providerName
+    };
+  }
+  return {
+    kind: "launch",
+    headed: !args.headless,
+    viewport: args.viewport ?? { width: 1366, height: 768 },
+    ...!args.headless && args.windowPosition ? { windowPosition: args.windowPosition } : {}
+  };
+}
 function writeDaemonExecOutput(output) {
   if (output?.stdout) {
     process.stdout.write(output.stdout);
@@ -427,14 +444,7 @@ async function runIntegrationFromFile(args, logger) {
     config: {
       session: args.session,
       experiments: args.experiments,
-      browser: args.providerName ? {
-        kind: "provider",
-        providerName: args.providerName
-      } : {
-        kind: "launch",
-        headed: !args.headless,
-        viewport: args.viewport ?? { width: 1366, height: 768 }
-      },
+      browser: createRunBrowserConfig(args),
       workflow: {
         integrationPath: absoluteIntegrationPath,
         params: args.params,
@@ -690,15 +700,18 @@ const runCommand = SimpleCLI.command({
     });
     console.log(`Connecting to ${providerName} browser...`);
   }
+  const headless = daemonProviderName ? true : headlessMode ?? false;
+  const windowPosition = headless ? void 0 : resolveWindowPosition(ctx.logger);
   await runIntegrationFromFile(
     {
       integrationPath: input.integrationFile,
       session: ctx.session,
       params,
       tsconfigPath: input.tsconfig,
-      headless: daemonProviderName ? true : headlessMode ?? false,
+      headless,
       visualize,
       viewport,
+      windowPosition,
       accessMode: input.readOnly ? "read-only" : input.writeAccess ? "write-access" : readLibrettoConfig().sessionMode ?? "write-access",
       providerName: daemonProviderName,
       stayOpenOnSuccess: input.stayOpenOnSuccess,
@@ -725,6 +738,7 @@ const executionCommands = {
   resume: resumeCommand
 };
 export {
+  createRunBrowserConfig,
   execCommand,
   execInput,
   executionCommands,

package/dist/cli/core/browser.js

@@ -1027,6 +1027,7 @@ export {
   normalizeUrl,
   resolvePath,
   resolveViewport,
+  resolveWindowPosition,
   runClose,
   runCloseAll,
   runConnect,

package/dist/cli/core/daemon/daemon.js

@@ -49,6 +49,7 @@ import {
 import { WorkflowController } from "../workflow-runner/runner.js";
 import { validateWorkflowInput } from "../../../shared/workflow/workflow.js";
 import { captureAuthProfileStorageState } from "../../../shared/workflow/auth-profile-state.js";
+import { applyWindowPosition } from "../../../shared/run/window-position.js";
 function isOperationalPage(page) {
   const url = page.url();
   return !url.startsWith("devtools://") && !url.startsWith("chrome-error://");
@@ -266,6 +267,7 @@ class BrowserDaemon {
       userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
     });
     const page = await context.newPage();
+    await applyWindowPosition(browser, context, page, config.windowPosition);
     page.setDefaultTimeout(3e4);
     page.setDefaultNavigationTimeout(45e3);
     const daemon = await BrowserDaemon.initialize({

package/dist/cli/core/deploy-artifact.js

@@ -22,7 +22,6 @@ import {
 } from "../../shared/workflow/workflow.js";
 import { normalizeCredentialNames } from "../../shared/workflow/credentials.js";
 const DEFAULT_RUNTIME_EXTERNALS = [
-  "libretto",
   "playwright",
   "playwright-core",
   "chromium-bidi"
@@ -408,14 +407,58 @@ function resolveDependencyVersion(sourceDir, packageName, fallbackVersion) {
     `Unable to determine a version for external package "${packageName}". Add it to your package.json or remove it from --external.`
   );
 }
+function resolveLibrettoDependencyVersion(sourceDir, packageName) {
+  try {
+    const librettoManifestPath = require2.resolve("libretto/package.json", {
+      paths: [sourceDir]
+    });
+    const version2 = readDependencyVersionFromManifest(
+      readPackageManifest(librettoManifestPath),
+      packageName
+    );
+    if (version2) {
+      return version2;
+    }
+  } catch {
+  }
+  const version = readDependencyVersionFromManifest(
+    readPackageManifest(join(CURRENT_LIBRETTO_PACKAGE_DIR, "package.json")),
+    packageName
+  );
+  if (version) {
+    return version;
+  }
+  try {
+    const manifestPath = require2.resolve(`${packageName}/package.json`, {
+      paths: [CURRENT_LIBRETTO_PACKAGE_DIR]
+    });
+    return readPackageManifest(manifestPath).version ?? null;
+  } catch {
+    return null;
+  }
+}
 function writeDeployManifest(args) {
+  const dependencyPackages = [
+    .../* @__PURE__ */ new Set([
+      ...BUILT_IN_MANIFEST_DEPENDENCIES,
+      ...args.runtimeExternals.filter(
+        (packageName) => resolveLibrettoDependencyVersion(args.sourceDir, packageName)
+      ),
+      ...args.additionalExternals
+    ])
+  ];
   const dependencies = Object.fromEntries(
-    [...BUILT_IN_MANIFEST_DEPENDENCIES, ...args.additionalExternals].map(
-      (packageName) => [
+    dependencyPackages.map((packageName) => {
+      const fallbackVersion = packageName === "libretto" ? args.librettoDependency : resolveLibrettoDependencyVersion(args.sourceDir, packageName) ?? void 0;
+      return [
         packageName,
-        packageName === "libretto" ? args.librettoDependency : resolveDependencyVersion(args.sourceDir, packageName)
-      ]
-    )
+        packageName === "libretto" ? args.librettoDependency : resolveDependencyVersion(
+          args.sourceDir,
+          packageName,
+          fallbackVersion
+        )
+      ];
+    })
   );
   writeFileSync(
     join(args.outputDir, "package.json"),
@@ -649,7 +692,7 @@ function createBootstrapSource(args) {
       authProfileRefresh: workflow.authProfileRefresh
     })});`
   ).join("\n");
-  return `import { createRequire } from "node:module";
+  return `import { createRequire, Module } from "node:module";
 import { existsSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -665,6 +708,45 @@ const BUNDLE_FILENAME = join(
 const nativeRequire = createRequire(
   join(tmpdir(), ${JSON.stringify("libretto-deploy-bootstrap.cjs")}),
 );
+const packageRequire = createRequire(import.meta.url || __filename);
+
+function isBarePackageSpecifier(specifier) {
+  return (
+    !specifier.startsWith(".") &&
+    !specifier.startsWith("/") &&
+    !specifier.startsWith("node:") &&
+    !/^[A-Za-z]:[\\\\/]/.test(specifier)
+  );
+}
+
+function loadImplementation() {
+  const originalRequire = Module.prototype.require;
+  function patchedRequire(specifier) {
+    try {
+      return originalRequire.call(this, specifier);
+    } catch (error) {
+      if (
+        error?.code === "MODULE_NOT_FOUND" &&
+        isBarePackageSpecifier(specifier)
+      ) {
+        Module.prototype.require = originalRequire;
+        try {
+          return packageRequire(specifier);
+        } finally {
+          Module.prototype.require = patchedRequire;
+        }
+      }
+      throw error;
+    }
+  }
+  Module.prototype.require = patchedRequire;
+
+  try {
+    return nativeRequire(ensureBundleFile());
+  } finally {
+    Module.prototype.require = originalRequire;
+  }
+}
 
 function ensureBundleFile() {
   if (!existsSync(BUNDLE_FILENAME)) {
@@ -679,7 +761,7 @@ function ensureBundleFile() {
 
 function createWorkflowProxy(workflowName, metadata) {
   const handler = async (ctx, input) => {
-    const impl = nativeRequire(ensureBundleFile());
+    const impl = loadImplementation();
     const target = getWorkflowFromModuleExports(impl, workflowName);
     if (!target || typeof target.run !== "function") {
       throw new Error(
@@ -716,6 +798,11 @@ ${exportLines}
 async function writeBundledDeployEntrypoint(args) {
   try {
     const unresolvedWorkspaceImports = /* @__PURE__ */ new Map();
+    const discoveryExternalPackages = /* @__PURE__ */ new Set([
+      ...args.externalPackages,
+      "libretto"
+    ]);
+    const unresolvedDiscoveryWorkspaceImports = /* @__PURE__ */ new Map();
     const implementationBuild = await build({
       absWorkingDir: args.absSourceDir,
       bundle: true,
@@ -736,6 +823,25 @@ async function writeBundledDeployEntrypoint(args) {
       target: "node20",
       write: false
     });
+    const discoveryBuild = await build({
+      absWorkingDir: args.absSourceDir,
+      bundle: true,
+      entryPoints: [args.absEntryPoint],
+      external: [...discoveryExternalPackages],
+      format: "cjs",
+      outfile: "prebundled-discovery.cjs",
+      platform: "node",
+      plugins: [
+        workspaceSourcePlugin(
+          args.workspacePackages,
+          discoveryExternalPackages,
+          unresolvedDiscoveryWorkspaceImports
+        )
+      ],
+      splitting: false,
+      target: "node20",
+      write: false
+    });
     const [unresolvedImport] = unresolvedWorkspaceImports;
     if (unresolvedImport) {
       const [importPath, packageDir] = unresolvedImport;
@@ -743,6 +849,13 @@ async function writeBundledDeployEntrypoint(args) {
         `Unable to resolve workspace import "${importPath}" from ${packageDir}.`
       );
     }
+    const [unresolvedDiscoveryImport] = unresolvedDiscoveryWorkspaceImports;
+    if (unresolvedDiscoveryImport) {
+      const [importPath, packageDir] = unresolvedDiscoveryImport;
+      throw new Error(
+        `Unable to resolve workspace import "${importPath}" from ${packageDir}.`
+      );
+    }
     const bundledImplementation = implementationBuild.outputFiles?.find(
       (file) => file.path.endsWith("prebundled.cjs")
     );
@@ -751,11 +864,17 @@ async function writeBundledDeployEntrypoint(args) {
         "Bundler did not produce a deployment implementation file."
       );
     }
+    const bundledDiscovery = discoveryBuild.outputFiles?.find(
+      (file) => file.path.endsWith("prebundled-discovery.cjs")
+    );
+    if (!bundledDiscovery) {
+      throw new Error("Bundler did not produce a deployment discovery file.");
+    }
     const workflows = discoverBundledWorkflows({
       absEntryPoint: args.absEntryPoint,
       absSourceDir: args.absSourceDir,
-      bundleBuffer: Buffer.from(bundledImplementation.contents),
-      externalPackages: args.externalPackages
+      bundleBuffer: Buffer.from(bundledDiscovery.contents),
+      externalPackages: discoveryExternalPackages
     });
     writeFileSync(
       join(args.outputDir, "index.js"),
@@ -825,6 +944,7 @@ async function createHostedDeployPackage(args) {
       deploymentName: args.deploymentName,
       librettoDependency,
       outputDir,
+      runtimeExternals: [...DEFAULT_RUNTIME_EXTERNALS],
       sourceDir: absSourceDir
     });
     writeDeployMetadata({ outputDir, workflows: workflowsWithShareableSource });

package/dist/shared/run/browser.js

@@ -9,6 +9,9 @@ import {
   SessionStateFileSchema
 } from "../state/session-state.js";
 import { readLibrettoConfig } from "../../cli/core/config.js";
+import {
+  applyWindowPosition
+} from "./window-position.js";
 async function pickFreePort() {
   return await new Promise((resolve, reject) => {
     const server = createServer();
@@ -27,38 +30,6 @@ 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,

package/dist/shared/run/window-position.d.ts

@@ -0,0 +1,9 @@
+import { Browser, BrowserContext, Page } from 'playwright';
+
+type WindowPosition = {
+    x: number;
+    y: number;
+};
+declare function applyWindowPosition(browser: Browser, context: BrowserContext, page: Page, windowPosition: WindowPosition | undefined): Promise<void>;
+
+export { type WindowPosition, applyWindowPosition };

package/dist/shared/run/window-position.js

@@ -0,0 +1,36 @@
+async function applyWindowPosition(browser, context, page, windowPosition) {
+  if (!windowPosition) {
+    return;
+  }
+  const requestedBounds = {
+    left: windowPosition.x,
+    top: windowPosition.y,
+    windowState: "normal"
+  };
+  let pageCdp;
+  let browserCdp;
+  try {
+    pageCdp = await context.newCDPSession(page);
+    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(() => {
+    });
+  }
+}
+export {
+  applyWindowPosition
+};

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

@@ -5,8 +5,8 @@ import '../../runtime/recovery/page-fallbacks.js';
 import 'ai';
 
 type LibrettoAuthenticateOptions = {
-    validate: (ctx: LibrettoWorkflowContext) => Promise<boolean> | boolean;
-    fallback: (ctx: LibrettoWorkflowContext, credentials: Record<string, string>) => Promise<void> | void;
+    isSignedIn: (ctx: LibrettoWorkflowContext) => Promise<boolean> | boolean;
+    signIn: (ctx: LibrettoWorkflowContext, credentials: Record<string, string>) => Promise<void> | void;
     credentials?: Record<string, unknown>;
     envPrefix?: string;
 };

package/dist/shared/workflow/authenticate.js

@@ -1,13 +1,13 @@
 async function librettoAuthenticate(ctx, options) {
-  if (await options.validate(ctx)) {
+  if (await options.isSignedIn(ctx)) {
     return { usedProfile: true };
   }
   const credentials = normalizeCredentials(
     options.credentials ?? readCredentialsFromEnv(options.envPrefix)
   );
-  await options.fallback(ctx, credentials);
-  if (!await options.validate(ctx)) {
-    throw new Error("Authentication fallback completed, but validation still failed.");
+  await options.signIn(ctx, credentials);
+  if (!await options.isSignedIn(ctx)) {
+    throw new Error("Sign-in completed, but the session is still not signed in.");
   }
   return { usedProfile: false };
 }

package/docs/releasing.md

@@ -66,7 +66,7 @@ The root `scripts/prepare-release.sh` script does the following:
 1. Checks that the working tree is clean.
 2. Updates local `main` from `origin/main`.
 3. Runs `pnpm install --frozen-lockfile`, `pnpm --filter libretto type-check`, and `pnpm --filter libretto test`.
-4. Checks whether `packages/affordance` changed since the current Libretto release tag. If it changed, the script runs Affordance type-check/tests and bumps `packages/affordance/package.json` by one patch version when the current Affordance version is already published to npm.
+4. Checks whether `packages/affordance` changed since the current Libretto release tag, excluding `packages/affordance/package.json` version-only changes. If source/package contents changed, the script runs Affordance type-check/tests and bumps `packages/affordance/package.json` by one patch version when the current Affordance version is already published to npm.
 5. Bumps the version in `packages/libretto/package.json`.
 6. Creates a release branch.
 7. Commits the version bump.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libretto",
-  "version": "0.6.28",
+  "version": "0.6.30-experimental-runtime-libretto.0",
   "description": "AI-powered browser automation library and CLI built on Playwright",
   "license": "MIT",
   "homepage": "https://libretto.sh",
@@ -33,6 +33,21 @@
       "default": "./dist/index.js"
     }
   },
+  "scripts": {
+    "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",
+    "lint": "lintcn lint --tsconfig tsconfig.json",
+    "type-check": "tsc --noEmit",
+    "test": "turbo run test:vitest --filter=libretto --log-order=grouped",
+    "test:vitest": "vitest run",
+    "test:watch": "vitest",
+    "cli": "node dist/index.js",
+    "generate-changelog": "tsx scripts/generate-changelog.ts",
+    "prepack": "pnpm run build"
+  },
   "peerDependencies": {
     "@ai-sdk/google": "^3.0.51",
     "@ai-sdk/google-vertex": "^4.0.80"
@@ -65,25 +80,11 @@
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.66",
     "@ai-sdk/openai": "^3.0.66",
+    "affordance": "workspace:^",
     "ai": "^6.0.116",
     "esbuild": "^0.27.0",
     "playwright": "^1.58.2",
     "tsx": "^4.21.0",
-    "zod": "^4.3.6",
-    "affordance": "^0.2.1"
-  },
-  "scripts": {
-    "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",
-    "lint": "lintcn lint --tsconfig tsconfig.json",
-    "type-check": "tsc --noEmit",
-    "test": "turbo run test:vitest --filter=libretto --log-order=grouped",
-    "test:vitest": "vitest run",
-    "test:watch": "vitest",
-    "cli": "node dist/index.js",
-    "generate-changelog": "tsx scripts/generate-changelog.ts"
+    "zod": "^4.3.6"
   }
-}
+}

package/skills/libretto/SKILL.md

@@ -4,7 +4,7 @@ description: "Browser automation CLI for building, maintaining, and running brow
 license: MIT
 metadata:
   author: saffron-health
-  version: "0.6.28"
+  version: "0.6.29"
 ---
 
 ## How Libretto Works
@@ -51,7 +51,11 @@ Prefer to enter sites at a user-facing URL (homepage, login, etc.) on the first
 - Do not treat visibility as interactivity. If an element will not act, inspect blockers before retrying.
 - Defer repo/code review until you begin generating code, unless the user explicitly asks for it earlier.
 - Read and follow guidelines in `references/code-generation-rules.md` before generating or editing production workflow code.
-- Validation requires a successful clean `run` with confirmation of the actual returned output, not just process success. Use the same headed or headless mode that the workflow run is already using.
+- For authenticated workflows, manual login is discovery only. After the user logs in, read only the sign-in action logs and identify the required credentials; if credentials are unclear, ask before writing code.
+- Add missing blank `LIBRETTO_CLOUD_<secret_name>=` entries without overwriting populated values. If any required credential is blank, stop and ask the user to fill it; until then, do not inspect logged-in pages, read authenticated network bodies, write workflow code, open validation sessions, or continue discovery.
+- Authenticated workflows must implement `librettoAuthenticate` with declared credentials before validation. Use a reusable `*_totp_secret` credential for authenticator-app MFA, not a one-time `otp_code`; text and email verification codes are not supported for fully automated sign-in.
+- Read `references/website-authentication.md` when you need `librettoAuthenticate` examples or auth-profile details.
+- Validation requires a successful clean `run` on a fresh, unauthenticated session with confirmation of the actual returned output, not just process success. Use the same headed or headless mode that the workflow run is already using.
 - After validation, always show the user: (1) the output/results from the validation run, and (2) the same command so they can re-run it themselves. Include any `--params`, `--headed`, or `--headless` flags the workflow needs.
 - Treat exploration sessions as disposable unless the user explicitly wants one kept open.
 - Get explicit user confirmation before mutating actions or replaying network requests that may have side effects.
@@ -232,13 +236,15 @@ Key fields: `id` (incrementing request id), `ts` (ISO timestamp), `pageId` (page
 [Context: The user wants to build a new browser workflow and does not yet know the page structure]
 Assistant: I'll inspect the real site first if needed, but before I finish I'll create `target-workflow.ts` so the task produces reusable automation code.
 Assistant: [Runs `npx libretto open https://target.example.com --headed`]
+Assistant: [If sign-in is required, follows the authenticated workflow rules before continuing]
 Assistant: [Reads `references/site-security-review.md` before choosing between passive network inspection, direct browser fetch calls, and Playwright-first automation]
 Assistant: [Runs `npx libretto snapshot --session <session>`]
 Assistant: [Uses `snapshot` and `exec` as needed to understand the site and decide the implementation path]
 Assistant: [Reads `references/code-generation-rules.md` before writing production workflow code]
 Assistant: I found the working path. I'll now create the workflow file and verify it.
 Assistant: [Creates or edits `target-workflow.ts` following `references/code-generation-rules.md`]
-Assistant: [Runs `npx libretto run ./target-workflow.ts --params '{"status":"open"}'` to validate]
+Assistant: [Runs `npx libretto run ./target-workflow.ts --params '{"status":"open"}'` on a fresh, unauthenticated session to verify both sign-in and workflow behavior]
+Assistant: [If sign-in validation passes and a reusable session is useful, adds an auth profile and reruns validation]
 Assistant: Validation passed. Here are the results:
 [Shows the output/results from the validation run]
 To run it again, use: npx libretto run ./target-workflow.ts --params '{"status":"open"}'
@@ -270,7 +276,7 @@ To run it again, use: npx libretto run ./integration.ts
 - Read `references/configuration-file-reference.md` when you need to inspect or change `.libretto/config.json` for viewport or session defaults.
 - Read `references/site-security-review.md` before reviewing the site's security posture and deciding whether to lead with network requests, passive interception, or Playwright DOM automation on a new site.
 - Read `references/code-generation-rules.md` before writing or editing production workflow files.
-- Read `references/auth-profiles.md` when auth-profile behavior is relevant.
+- Read `references/website-authentication.md` when website sign-in implementation or auth-profile behavior is relevant.
 - Read `references/pages-and-page-targeting.md` when a session has multiple open pages or you need `--page`.
 - Read `references/action-logs.md` for full action log field descriptions and user-vs-agent event semantics.
 - If the workflow code is deployed to the Libretto Cloud platform and you need to reference its API docs, fetch [https://libretto.sh/docs/llms.txt](https://libretto.sh/docs/llms.txt) and follow the relevant page links.

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

@@ -49,7 +49,7 @@ Key points:
 - After validation is complete and the workflow is confirmed working end to end, remove all `pause()` calls and pause-only workflow params unless the user explicitly says to keep them.
 - The browser is launched and closed automatically by the CLI. Do not launch or close it in the handler.
 
-## Workflow Credentials And Auth Profiles
+## Workflow Credentials And Authentication
 
 Declare `credentials` for runtime secrets instead of putting them in the Zod input schema or `--params`. Only declared names are injected into `input.credentials`; local runs read matching `LIBRETTO_CLOUD_` variables from `.env`, and hosted runs read matching Libretto Cloud credentials. For example, `LIBRETTO_CLOUD_OPENAI_API_KEY` becomes `input.credentials.openai_api_key`.
 
@@ -70,14 +70,7 @@ export default workflow("sentimentWorkflow", {
 });
 ```
 
-For logged-in website workflows, unless the user says otherwise, generate both:
-
-- `authProfile: { name, refresh: true }`
-- `librettoAuthenticate(...)` fallback login logic using declared credentials such as `credentials: ["username", "password"]`
-
-After generating or validating a credentialed workflow, include the local `.env` variable names the user must set, and never print secret values.
-
-The fallback should validate the signed-in state, log in when validation fails, and validate again before continuing. Follow `references/auth-profiles.md` for profile naming, refresh behavior, hosted profile behavior, and the fallback-login pattern.
+For website workflows that require signing in, build working sign-in logic with `librettoAuthenticate` and verify it from a clean signed-out browser before adding an auth profile. Follow `references/website-authentication.md`.
 
 ## Workflow Error Handling
 

package/skills/libretto/references/site-security-review.md

@@ -43,7 +43,7 @@ General guidance: determine whether the site has bot protection and roughly how
 
 ### Probe 2: Fetch and XHR Interception
 
-Check whether the site has monkey-patched `window.fetch` or `XMLHttpRequest`. If it has, making your own fetch calls from `page.evaluate()` is risky because the site can inspect call stacks and detect calls that do not originate from its own code.
+Check whether the site has monkey-patched `window.fetch` or `XMLHttpRequest`. Patching is a caution signal, not an automatic blocker. Browser-context network requests are usually fine when the target endpoint is already called by the site with fetch/XHR and there is no strong bot-protection evidence.
 
 ```js
 window.fetch.toString()
@@ -52,7 +52,7 @@ Object.getOwnPropertyDescriptor(window, 'fetch')
 window.fetch.hasOwnProperty('prototype')
 ```
 
-Important: some sites use `Proxy` to wrap fetch, which makes `toString()` still return `"[native code]"`. The prototype check is a heuristic, not definitive. If you see any sign of fetch interception, treat it as patched.
+Important: ordinary app instrumentation and Libretto's own page-stability tracking can also wrap fetch/XHR. Treat browser fetch as risky only when the wrapper appears security-related, obfuscated, tied to bot-protection scripts, or likely to inspect call stacks. Some `Proxy` wrappers still stringify as `"[native code]"`, so these checks are only heuristics.
 
 ## Choosing a Data Capture Strategy
 
@@ -66,7 +66,7 @@ When to prioritize this:
 
 - The target endpoint is normally called by the site with fetch/XHR
 - No enterprise bot protection is detected
-- `fetch` is not monkey-patched
+- No security-related fetch/XHR interception is detected, or the observed wrapper appears to be ordinary app instrumentation
 - The API responses are parseable and useful
 - You need data that requires many API calls (deep pagination, bulk queries) where driving the UI would be slow
 
@@ -83,7 +83,7 @@ Listen to network responses that the browser naturally makes as you navigate. Yo
 When to prioritize this:
 
 - Enterprise bot protection is detected
-- `fetch` is monkey-patched
+- Security-related fetch/XHR interception is detected
 - The site's normal UI flow triggers API calls that return the data you need
 - You want to minimize detection risk as much as possible
 
@@ -112,8 +112,9 @@ Trade-off: it is slower, more fragile against DOM changes, and you only get data
 
 | Site Profile | Primary Strategy | Supplement With |
 | --- | --- | --- |
-| No bot protection, fetch/XHR endpoint, fetch not patched | A (`page.evaluate(fetch)`) | Playwright for navigation/auth |
-| No bot protection, fetch is patched or endpoint is not fetch/XHR | B (`page.on('response', ...)`) | Playwright for navigation; DOM extraction as fallback |
+| No bot protection, fetch/XHR endpoint, no security-related interception | A (`page.evaluate(fetch)`) | Playwright for navigation/auth |
+| No bot protection, harmless app instrumentation, fetch/XHR endpoint | A (`page.evaluate(fetch)`) | B (`page.on('response', ...)`) if requests fail |
+| No bot protection, security-related interception or endpoint is not fetch/XHR | B (`page.on('response', ...)`) | Playwright for navigation; DOM extraction as fallback |
 | Bot protection detected | B (`page.on('response', ...)`) | Playwright for navigation; cautious use of `page.evaluate(fetch)` only if needed |
 | Server-rendered content (no API calls) | C (DOM extraction) | Playwright for all interaction |