chainlesschain 0.166.13 → 0.166.14

package/src/commands/skill.js

@@ -58,6 +58,7 @@ import {
   removeCliPacks,
 } from "../lib/skill-packs/generator.js";
 import { CLI_PACK_DOMAINS } from "../lib/skill-packs/schema.js";
+import { registerRecordReplayCommands } from "./record-replay.js";
 
 const LAYER_LABELS = {
   bundled: chalk.blue("[bundled]"),
@@ -291,6 +292,8 @@ export function registerSkillCommand(program) {
 
   const loader = new CLISkillLoader();
 
+  registerRecordReplayCommands(skill);
+
   // skill list
   skill
     .command("list")

package/src/data/changelog.json

@@ -1,6 +1,19 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.14",
+      "cliVersions": ["0.166.13", "0.166.14"],
+      "date": "2026-08-30",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.14: restore Docker-optional startup on Windows",
+          "body": "> `chainlesschain` **0.166.13 -> 0.166.14** (hotfix candidate, 2026-08-30).\n\n- **Docker remains opt-in**: a normal agent session no longer probes or\n  requires Docker unless the CLI flag, settings, or managed policy explicitly\n  selects container isolation.\n- **Windows executable lookup**: bare commands resolve through `PATHEXT`\n  before launch, so Docker Desktop's POSIX `docker` script cannot shadow\n  `docker.exe` and trigger `CreateProcessAsUser` error 193.\n- **Explicit isolation stays fail-closed**: `workspace-write`, `strict`, and\n  managed sandbox requirements still reject unavailable engines instead of\n  silently degrading."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.13",

package/src/lib/agent-sandbox.js

@@ -259,14 +259,10 @@ export function normalizeAgentSandbox(value, options = {}) {
  */
 export function normalizeAgentSandboxMode(mode, value, options = {}) {
   if (mode == null || mode === "") {
-    // Public agent execution defaults to a real, fail-closed workspace
-    // sandbox with networking disabled. Bare-host execution remains available
-    // only through the explicit `off` mode below, where managed policy can
-    // prohibit it and the CLI records a high-risk security event.
-    return normalizeAgentSandboxMode("workspace-write", value || true, {
-      ...options,
-      network: false,
-    });
+    // Keep the container sandbox opt-in unless CLI/settings policy explicitly
+    // enables it. The platform process broker still applies its native
+    // boundary, but starting a normal agent must not require Docker.
+    return normalizeAgentSandbox(value, options);
   }
   if (!AGENT_SANDBOX_MODES.includes(mode)) {
     const error = new Error(

package/src/lib/agent-team/team-message-tools.js

@@ -5,6 +5,7 @@ import {
   TEAM_MESSAGE_BRIDGE_MAX_WAIT_MS,
   TEAM_MESSAGE_BRIDGE_PROTOCOL,
 } from "./team-message-bridge.js";
+import { resolveCredentialEnvironmentValue } from "../process-execution-broker/credential-transport.js";
 
 export const TEAM_MESSAGE_TOOL_NAMES = Object.freeze([
   "team_send",
@@ -177,21 +178,38 @@ function descriptor(name) {
   });
 }
 
-export function resolveTeamMessageToolBundle({
+export async function resolveTeamMessageToolBundle({
   env = process.env,
   call = callTeamMessageBridge,
+  resolveCredential = resolveCredentialEnvironmentValue,
 } = {}) {
   const endpoint = env.CC_TEAM_MESSAGE_BRIDGE_ENDPOINT;
-  const token = env.CC_TEAM_MESSAGE_BRIDGE_TOKEN;
+  const tokenReference = env.CC_CRED_REF_CC_TEAM_MESSAGE_BRIDGE_TOKEN;
   const protocol = Number(env.CC_TEAM_MESSAGE_BRIDGE_PROTOCOL);
-  if (!endpoint && !token && !env.CC_TEAM_MESSAGE_BRIDGE_PROTOCOL) return null;
+  if (
+    !endpoint &&
+    !env.CC_TEAM_MESSAGE_BRIDGE_TOKEN &&
+    !tokenReference &&
+    !env.CC_TEAM_MESSAGE_BRIDGE_PROTOCOL
+  ) {
+    return null;
+  }
   if (
     typeof endpoint !== "string" ||
     !endpoint ||
+    protocol !== TEAM_MESSAGE_BRIDGE_PROTOCOL
+  ) {
+    const error = new Error("Team message bridge environment is invalid");
+    error.code = "TEAM_MESSAGE_BRIDGE_CONFIG_INVALID";
+    throw error;
+  }
+  const token = await resolveCredential("CC_TEAM_MESSAGE_BRIDGE_TOKEN", {
+    env,
+  });
+  if (
     typeof token !== "string" ||
     token.length !== 64 ||
-    !/^[a-f0-9]{64}$/u.test(token) ||
-    protocol !== TEAM_MESSAGE_BRIDGE_PROTOCOL
+    !/^[a-f0-9]{64}$/u.test(token)
   ) {
     const error = new Error("Team message bridge environment is invalid");
     error.code = "TEAM_MESSAGE_BRIDGE_CONFIG_INVALID";

package/src/lib/process-execution-broker/credential-transport.js

@@ -375,4 +375,35 @@ export async function resolveCredentialRefOverTransport(refId, options = {}) {
   });
 }
 
+/**
+ * Resolve one named environment credential without copying plaintext back into
+ * process.env. Direct launches keep accepting the original environment value;
+ * brokered launches exchange the short-lived, target-bound reference that the
+ * ProcessExecutionBroker placed in CC_CRED_REF_<NAME>.
+ */
+export async function resolveCredentialEnvironmentValue(key, options = {}) {
+  if (!/^[A-Z][A-Z0-9_]*$/u.test(String(key || ""))) {
+    throw transportError(
+      "CC_CREDENTIAL_INVALID_REQUEST",
+      "Credential environment key is invalid",
+    );
+  }
+  const env = options.env || process.env;
+  const value = env[key];
+  const refId = env[`CC_CRED_REF_${key}`];
+  const hasValue = typeof value === "string" && value.length > 0;
+  const hasReference = typeof refId === "string" && refId.length > 0;
+  if (hasValue && hasReference) {
+    throw transportError(
+      "CC_CREDENTIAL_INVALID_REQUEST",
+      "Credential environment contains both plaintext and a broker reference",
+    );
+  }
+  if (hasValue) return value;
+  if (!hasReference) return null;
+  const resolveReference =
+    options.resolveReference || resolveCredentialRefOverTransport;
+  return await resolveReference(refId, { env });
+}
+
 export { TRANSPORT_VERSION };

package/src/lib/process-execution-broker/index.js

@@ -29,6 +29,7 @@ import path from "node:path";
 import * as fs from "node:fs";
 import * as tty from "node:tty";
 import { createRequire } from "node:module";
+import { AsyncLocalStorage } from "node:async_hooks";
 
 const require = createRequire(import.meta.url);
 
@@ -996,6 +997,7 @@ class ProcessExecutionBroker extends EventEmitter {
     this._ptyAdapter = createNativePtyAdapter();
     this._hooksEventSink = null;
     this._workspaceTransactionManagers = new Map();
+    this._ambientProcessContext = new AsyncLocalStorage();
 
     this._ensureLogDir();
     this._loadPermissions();
@@ -1029,6 +1031,76 @@ class ProcessExecutionBroker extends EventEmitter {
     return "prompt";
   }
 
+  _withAmbientProcessContext(command, options = {}) {
+    const context = this._ambientProcessContext.getStore();
+    if (!context) return options;
+    const commandIdentity = (() => {
+      if (typeof command !== "string" || !command) return "";
+      const normalized = path.isAbsolute(command)
+        ? path.resolve(command)
+        : command;
+      return process.platform === "win32"
+        ? normalized.toLowerCase()
+        : normalized;
+    })();
+    const allowed = context.allowedCommands.includes(commandIdentity);
+    return {
+      ...options,
+      origin: context.origin,
+      scope: context.scope,
+      policy: allowed ? context.policy : "deny",
+      auditContext: context.auditContext,
+    };
+  }
+
+  runWithProcessContext(
+    {
+      origin,
+      policy = "allow",
+      scope = "default",
+      allowedCommands = [],
+      auditContext,
+    } = {},
+    operation,
+  ) {
+    const safeOrigin = String(origin || "");
+    if (
+      !/^[A-Za-z][A-Za-z0-9:._-]{0,127}$/u.test(safeOrigin) ||
+      !["allow", "deny", "prompt"].includes(policy) ||
+      typeof operation !== "function" ||
+      !Array.isArray(allowedCommands) ||
+      allowedCommands.length < 1 ||
+      allowedCommands.length > 16
+    ) {
+      const error = new Error("Process execution context is invalid");
+      error.code = "PROCESS_CONTEXT_INVALID";
+      throw error;
+    }
+    const normalizedCommands = allowedCommands.map((command) => {
+      if (typeof command !== "string" || !path.isAbsolute(command)) {
+        const error = new Error(
+          "Process execution context commands must be absolute paths",
+        );
+        error.code = "PROCESS_CONTEXT_INVALID";
+        throw error;
+      }
+      const normalized = path.resolve(command);
+      return process.platform === "win32"
+        ? normalized.toLowerCase()
+        : normalized;
+    });
+    return this._ambientProcessContext.run(
+      Object.freeze({
+        origin: safeOrigin,
+        policy,
+        scope: String(scope || "default").slice(0, 128),
+        allowedCommands: Object.freeze([...new Set(normalizedCommands)]),
+        auditContext,
+      }),
+      operation,
+    );
+  }
+
   _isDangerousCommand(command) {
     if (typeof command !== "string") return false;
     const lower = command.toLowerCase();
@@ -4470,6 +4542,7 @@ class ProcessExecutionBroker extends EventEmitter {
   }
 
   spawn(command, args, options = {}) {
+    options = this._withAmbientProcessContext(command, options);
     const executionId = crypto.randomUUID();
     const startTime = Date.now();
     const origin = options.origin || "unknown";
@@ -4857,6 +4930,7 @@ class ProcessExecutionBroker extends EventEmitter {
   }
 
   spawnSync(command, args, options = {}) {
+    options = this._withAmbientProcessContext(command, options);
     const executionId = crypto.randomUUID();
     const startTime = Date.now();
     const origin = options.origin || "unknown";

package/src/lib/process-execution-broker/windows-sandbox.cs

@@ -1683,8 +1683,12 @@ namespace ChainlessChain.WindowsSandbox
                 string[] configured = pathExt.Split(
                     new[] { ';' },
                     StringSplitOptions.RemoveEmptyEntries);
-                extensions = new string[configured.Length + 1];
-                extensions[0] = String.Empty;
+                // Match Windows command lookup: a bare command name is
+                // resolved through PATHEXT. Trying an extensionless file first
+                // can select Docker's adjacent POSIX `docker` shell script
+                // instead of docker.exe, which CreateProcessAsUser rejects
+                // with ERROR_BAD_EXE_FORMAT (193).
+                extensions = new string[configured.Length];
                 for (int index = 0; index < configured.Length; index++)
                 {
                     string extension = configured[index].Trim();
@@ -1697,7 +1701,7 @@ namespace ChainlessChain.WindowsSandbox
                         throw new InvalidDataException(
                             "Target PATHEXT contains an invalid extension");
                     }
-                    extensions[index + 1] = extension;
+                    extensions[index] = extension;
                 }
             }
 

package/src/lib/record-replay/browser-target-policy.js

@@ -0,0 +1,406 @@
+import { createHash } from "node:crypto";
+
+const MAX_HTML_CHARS = 1_000_000;
+const MAX_ALLOWED_ORIGINS = 8;
+const MAX_URL_CHARS = 4_096;
+const MAX_STORAGE_STATE_BYTES = 2 * 1024 * 1024;
+const MAX_STORAGE_STATE_DEPTH = 16;
+const MAX_STORAGE_STATE_NODES = 10_000;
+const SHA256_PATTERN = /^sha256:[a-f0-9]{64}$/u;
+
+function targetError(code, message) {
+  const error = new Error(message);
+  error.name = "RecordedSkillBrowserTargetError";
+  error.code = code;
+  return error;
+}
+
+function canonicalValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalValue);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.keys(value)
+      .sort()
+      .map((key) => [key, canonicalValue(value[key])]),
+  );
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value))
+    return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}
+
+function boundedCanonicalStorageState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      "browser storage state must be a JSON object",
+    );
+  }
+  const seen = new WeakSet();
+  const pending = [{ value, depth: 0 }];
+  let nodes = 0;
+  while (pending.length > 0) {
+    const current = pending.pop();
+    const item = current.value;
+    nodes += 1;
+    if (
+      nodes > MAX_STORAGE_STATE_NODES ||
+      current.depth > MAX_STORAGE_STATE_DEPTH
+    ) {
+      throw targetError(
+        "CC_RECORD_TARGET_INVALID",
+        "browser storage state exceeds its structural limits",
+      );
+    }
+    if (!item || typeof item !== "object") {
+      if (
+        typeof item === "undefined" ||
+        typeof item === "bigint" ||
+        typeof item === "function" ||
+        typeof item === "symbol" ||
+        (typeof item === "number" && !Number.isFinite(item))
+      ) {
+        throw targetError(
+          "CC_RECORD_TARGET_INVALID",
+          "browser storage state must contain only JSON values",
+        );
+      }
+      continue;
+    }
+    if (seen.has(item)) {
+      throw targetError(
+        "CC_RECORD_TARGET_INVALID",
+        "browser storage state must not contain cycles or shared objects",
+      );
+    }
+    seen.add(item);
+    if (
+      !Array.isArray(item) &&
+      Object.getPrototypeOf(item) !== Object.prototype
+    ) {
+      throw targetError(
+        "CC_RECORD_TARGET_INVALID",
+        "browser storage state must contain plain JSON objects",
+      );
+    }
+    const children = Array.isArray(item) ? item : Object.values(item);
+    if (children.length > MAX_STORAGE_STATE_NODES) {
+      throw targetError(
+        "CC_RECORD_TARGET_INVALID",
+        "browser storage state exceeds its structural limits",
+      );
+    }
+    for (const child of children) {
+      pending.push({ value: child, depth: current.depth + 1 });
+    }
+  }
+  const canonical = canonicalValue(value);
+  if (
+    Buffer.byteLength(JSON.stringify(canonical), "utf8") >
+    MAX_STORAGE_STATE_BYTES
+  ) {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      "browser storage state exceeds the 2 MiB limit",
+    );
+  }
+  return deepFreeze(canonical);
+}
+
+function digest(value, domain) {
+  const bytes = Buffer.isBuffer(value)
+    ? value
+    : Buffer.from(
+        typeof value === "string"
+          ? value
+          : JSON.stringify(canonicalValue(value)),
+      );
+  return `sha256:${createHash("sha256")
+    .update(domain)
+    .update("\0")
+    .update(bytes)
+    .digest("hex")}`;
+}
+
+function isLoopback(hostname) {
+  const normalized = String(hostname || "").toLowerCase();
+  return (
+    normalized === "localhost" ||
+    normalized === "127.0.0.1" ||
+    normalized === "[::1]" ||
+    normalized === "::1"
+  );
+}
+
+function safeUrl(value, { originOnly = false } = {}) {
+  if (
+    typeof value !== "string" ||
+    value.length < 1 ||
+    value.length > MAX_URL_CHARS
+  ) {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      `browser target URL must be no longer than ${MAX_URL_CHARS} characters`,
+    );
+  }
+  let parsed;
+  try {
+    parsed = new URL(String(value));
+  } catch {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      "browser target must be an absolute URL",
+    );
+  }
+  if (
+    parsed.username ||
+    parsed.password ||
+    (parsed.protocol !== "https:" &&
+      !(parsed.protocol === "http:" && isLoopback(parsed.hostname)))
+  ) {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      "browser targets require HTTPS; HTTP is allowed only for loopback testing and URL credentials are forbidden",
+    );
+  }
+  if (originOnly && parsed.href !== `${parsed.origin}/`) {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      "allowed origins must not contain a path, query, or fragment",
+    );
+  }
+  return parsed;
+}
+
+export function createRecordedSkillNetworkPolicy({
+  mode = "deny",
+  allowedOrigins = [],
+} = {}) {
+  if (mode === "deny") {
+    if (!Array.isArray(allowedOrigins) || allowedOrigins.length > 0) {
+      throw targetError(
+        "CC_RECORD_TARGET_INVALID",
+        "deny network policy cannot retain allowed origins",
+      );
+    }
+    const body = { mode: "deny", allowedOrigins: [] };
+    return deepFreeze({
+      ...body,
+      digest: digest(body, "cc.record-replay.network-policy/v1"),
+    });
+  }
+  if (mode !== "allowlist" || !Array.isArray(allowedOrigins)) {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      "browser network policy is invalid",
+    );
+  }
+  const origins = [
+    ...new Set(
+      allowedOrigins.map(
+        (value) => safeUrl(value, { originOnly: true }).origin,
+      ),
+    ),
+  ].sort();
+  if (origins.length < 1 || origins.length > MAX_ALLOWED_ORIGINS) {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      `browser target requires between 1 and ${MAX_ALLOWED_ORIGINS} allowed origins`,
+    );
+  }
+  const body = { mode: "allowlist", allowedOrigins: origins };
+  return deepFreeze({
+    ...body,
+    digest: digest(body, "cc.record-replay.network-policy/v1"),
+  });
+}
+
+export function digestRecordedSkillStorageState(storageState) {
+  if (storageState == null) return null;
+  return digest(
+    boundedCanonicalStorageState(storageState),
+    "cc.record-replay.browser-storage-state/v1",
+  );
+}
+
+export function prepareRecordedSkillBrowserTarget({
+  html,
+  url,
+  allowedOrigins = [],
+  storageState,
+  identity = "anonymous",
+} = {}) {
+  const hasHtml = typeof html === "string" && html.length > 0;
+  const hasUrl = typeof url === "string" && url.length > 0;
+  if (hasHtml === hasUrl) {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      "provide exactly one self-contained HTML fixture or URL target",
+    );
+  }
+  const safeIdentity = String(identity || "anonymous").trim();
+  if (!/^[A-Za-z][A-Za-z0-9._-]{0,127}$/u.test(safeIdentity)) {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      "browser identity label is invalid",
+    );
+  }
+  if (hasHtml) {
+    if (
+      html.length > MAX_HTML_CHARS ||
+      allowedOrigins.length > 0 ||
+      storageState != null
+    ) {
+      throw targetError(
+        "CC_RECORD_TARGET_INVALID",
+        "self-contained HTML recording cannot use network origins or browser credentials",
+      );
+    }
+    const networkPolicy = createRecordedSkillNetworkPolicy({ mode: "deny" });
+    return deepFreeze({
+      adapter: "self-contained-html",
+      html,
+      url: null,
+      targetDigest: digest(html, "cc.record-replay.ui-fixture/v1"),
+      networkPolicy,
+      storageState: null,
+      storageStateDigest: null,
+      identity: safeIdentity,
+    });
+  }
+  const target = safeUrl(url);
+  const networkPolicy = createRecordedSkillNetworkPolicy({
+    mode: "allowlist",
+    allowedOrigins:
+      allowedOrigins.length > 0 ? allowedOrigins : [target.origin],
+  });
+  if (!networkPolicy.allowedOrigins.includes(target.origin)) {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      "target origin must be present in the network allowlist",
+    );
+  }
+  const normalizedStorageState =
+    storageState == null ? null : boundedCanonicalStorageState(storageState);
+  return deepFreeze({
+    adapter: "url-origin",
+    html: null,
+    url: target.href,
+    targetDigest: digest(target.href, "cc.record-replay.ui-url/v1"),
+    networkPolicy,
+    storageState: normalizedStorageState,
+    storageStateDigest: digestRecordedSkillStorageState(normalizedStorageState),
+    identity: safeIdentity,
+  });
+}
+
+export function recordedSkillBrowserEnvironment(target) {
+  if (
+    !target ||
+    !["self-contained-html", "url-origin"].includes(target.adapter) ||
+    !SHA256_PATTERN.test(String(target.targetDigest || ""))
+  ) {
+    throw targetError(
+      "CC_RECORD_TARGET_INVALID",
+      "prepared browser target is invalid",
+    );
+  }
+  return deepFreeze({
+    adapter: target.adapter,
+    browser: "chromium",
+    targetDigest: target.targetDigest,
+    selectorContract: "record-replay-dom-v1",
+    networkPolicy: Object.freeze({
+      mode: target.networkPolicy.mode,
+      allowedOrigins: Object.freeze([...target.networkPolicy.allowedOrigins]),
+      digest: target.networkPolicy.digest,
+    }),
+    identity: target.identity,
+    storageStateDigest: target.storageStateDigest,
+  });
+}
+
+export function assertRecordedSkillBrowserBinding(
+  target,
+  { source, environment } = {},
+) {
+  let reviewedPolicy;
+  try {
+    reviewedPolicy = createRecordedSkillNetworkPolicy({
+      mode: environment?.networkPolicy?.mode,
+      allowedOrigins: environment?.networkPolicy?.allowedOrigins || [],
+    });
+  } catch {
+    reviewedPolicy = null;
+  }
+  if (
+    !source ||
+    target?.adapter !== source.adapter ||
+    target?.targetDigest !== source.targetDigest ||
+    environment?.adapter !== source.adapter ||
+    environment?.targetDigest !== source.targetDigest
+  ) {
+    throw targetError(
+      "CC_RECORD_TARGET_DRIFT",
+      "browser target no longer matches the reviewed recording",
+    );
+  }
+  if (
+    (environment.storageStateDigest || null) !==
+    (target.storageStateDigest || null)
+  ) {
+    throw targetError(
+      "CC_RECORD_CREDENTIAL_DRIFT",
+      "browser storage state no longer matches the reviewed credential binding",
+    );
+  }
+  if (
+    environment.identity !== target.identity ||
+    reviewedPolicy?.digest !== environment.networkPolicy?.digest ||
+    reviewedPolicy?.digest !== target.networkPolicy?.digest
+  ) {
+    throw targetError(
+      "CC_RECORD_ENVIRONMENT_DRIFT",
+      "browser identity or network policy no longer matches the reviewed recording",
+    );
+  }
+  return true;
+}
+
+export function requestAllowedByRecordedSkillPolicy(rawUrl, target) {
+  let parsed;
+  try {
+    parsed = new URL(String(rawUrl));
+  } catch {
+    return false;
+  }
+  if (["about:", "data:"].includes(parsed.protocol)) return true;
+  if (parsed.protocol === "blob:") {
+    return (
+      target.networkPolicy.mode === "allowlist" &&
+      target.networkPolicy.allowedOrigins.includes(parsed.origin)
+    );
+  }
+  if (!["http:", "https:"].includes(parsed.protocol)) return false;
+  return (
+    target.networkPolicy.mode === "allowlist" &&
+    target.networkPolicy.allowedOrigins.includes(parsed.origin)
+  );
+}
+
+export function navigationAllowedByRecordedSkillPolicy(rawUrl, target) {
+  let parsed;
+  try {
+    parsed = new URL(String(rawUrl));
+  } catch {
+    return false;
+  }
+  return (
+    ["http:", "https:"].includes(parsed.protocol) &&
+    target.networkPolicy.mode === "allowlist" &&
+    target.networkPolicy.allowedOrigins.includes(parsed.origin)
+  );
+}

package/src/lib/record-replay/index.js

@@ -1,2 +1,6 @@
 export * from "./skill-recorder.js";
 export * from "./playwright-ui-driver.js";
+export * from "./playwright-ui-recorder.js";
+export * from "./recorded-skill-store.js";
+export * from "./recorded-skill-package.js";
+export * from "./browser-target-policy.js";