@yanlinglabs/winter-agent-sdk 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,3 +1,26 @@
+import {
+  BRAND_TOKEN_RE2,
+  FIRST_PARTY_ORIGINATORS2,
+  WINTER_BRAND2,
+  resolveBrand2,
+  envName2,
+  mcpToolName2,
+  userAgent2,
+  isUnset2,
+  resolveWinterHome2,
+  resolveKeychainServiceForProfile2,
+  WinterStoreError2,
+  WinterStoreLeaseError2,
+  DIALECT_RECORD_ENTRY_TYPE2,
+  PROVIDER_STATE_FILE_SUFFIX2,
+  WinterCompatibilitySessionStore2
+} from "./index-9e98bg1r.js";
+import {
+  deliveryUncertain2,
+  refused2,
+  unavailable2
+} from "./index-51ysrfm8.js";
+
 // src/query.ts
 import { randomUUID } from "node:crypto";
 
@@ -35,120 +58,14 @@ function splitFrames(chunk, carry) {
   return { frames, carry: nextCarry };
 }
 
-// src/brand.ts
-var BRAND_TOKEN_RE = /^[a-z][a-z0-9-]{0,31}$/;
-var DOT_DIR_RE = /^\.[a-z][a-z0-9-]{0,31}$/;
-var INSTRUCTIONS_FILE_RE = /^[A-Z][A-Z0-9_]{0,31}\.md$/;
-var ENV_PREFIX_RE = /^[A-Z][A-Z0-9]{0,15}_$/;
-var KEYCHAIN_SERVICE_RE = /^[a-z][a-z0-9.-]{0,63}$/;
-var MAX_PRODUCT_NAME = 64;
-var CONTROL_BYTE_RE = /[\u0000-\u001f\u007f]/;
-function isHttpsUrl(value) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    return false;
-  }
-  if (CONTROL_BYTE_RE.test(value))
-    return false;
-  return url.protocol === "https:";
-}
-var FIRST_PARTY_ORIGINATORS = ["codex", "codex_cli_rs", "openai", "anthropic", "claude", "claude-code"];
-var WINTER_BRAND = Object.freeze({
-  productName: "Winter",
-  packageName: "winter-agent-sdk",
-  homeDirName: ".winter",
-  projectDirName: ".winter",
-  instructionsFile: "WINTER.md",
-  envPrefix: "WINTER_",
-  keychainService: "com.winter.core",
-  mcpServerName: "winter",
-  presetName: "winter_code",
-  processLabel: "winter",
-  codexOriginator: "winter",
-  tempRootName: "winter",
-  pluginManifestDir: ".winter-plugin",
-  contactUrl: "https://github.com/yanlingLabs/winter-agent-sdk"
-});
-var FIELD_RULES = [
-  { field: "packageName", re: BRAND_TOKEN_RE, shape: "a lowercase token of 1-32 chars: a letter, then letters/digits/hyphens" },
-  { field: "mcpServerName", re: BRAND_TOKEN_RE, shape: "a lowercase token of 1-32 chars: a letter, then letters/digits/hyphens" },
-  { field: "processLabel", re: BRAND_TOKEN_RE, shape: "a lowercase token of 1-32 chars: a letter, then letters/digits/hyphens" },
-  { field: "tempRootName", re: BRAND_TOKEN_RE, shape: "a lowercase token of 1-32 chars: a letter, then letters/digits/hyphens" },
-  { field: "codexOriginator", re: BRAND_TOKEN_RE, shape: "a lowercase token of 1-32 chars: a letter, then letters/digits/hyphens" },
-  { field: "homeDirName", re: DOT_DIR_RE, shape: "a LEADING DOT then a lowercase token (it names a hidden directory)" },
-  { field: "projectDirName", re: DOT_DIR_RE, shape: "a LEADING DOT then a lowercase token (it names a hidden directory)" },
-  { field: "pluginManifestDir", re: DOT_DIR_RE, shape: "a LEADING DOT then a lowercase token (it names a hidden directory)" },
-  { field: "instructionsFile", re: INSTRUCTIONS_FILE_RE, shape: 'an UPPERCASE name with a `.md` extension, e.g. "ACME.md"' },
-  { field: "envPrefix", re: ENV_PREFIX_RE, shape: 'an UPPERCASE prefix ENDING IN AN UNDERSCORE, e.g. "ACME_"' },
-  { field: "keychainService", re: KEYCHAIN_SERVICE_RE, shape: 'a lowercase reverse-DNS-style service name, e.g. "com.acme.core"' }
-];
-function resolveBrand(partial) {
-  const p = partial ?? {};
-  const pick = (key) => p[key] === undefined ? WINTER_BRAND[key] : p[key];
-  const brand = {
-    productName: pick("productName"),
-    packageName: pick("packageName"),
-    homeDirName: pick("homeDirName"),
-    projectDirName: pick("projectDirName"),
-    instructionsFile: pick("instructionsFile"),
-    envPrefix: pick("envPrefix"),
-    keychainService: pick("keychainService"),
-    mcpServerName: pick("mcpServerName"),
-    presetName: pick("presetName"),
-    processLabel: pick("processLabel"),
-    codexOriginator: pick("codexOriginator"),
-    tempRootName: pick("tempRootName"),
-    pluginManifestDir: pick("pluginManifestDir"),
-    contactUrl: pick("contactUrl")
-  };
-  for (const key of Object.keys(brand)) {
-    if (typeof brand[key] !== "string")
-      return { ok: false, reason: `brand.${key}: expected a string, got ${brand[key] === null ? "null" : typeof brand[key]}` };
-  }
-  if (brand.productName.length === 0 || brand.productName.length > MAX_PRODUCT_NAME) {
-    return { ok: false, reason: `brand.productName: expected 1-${MAX_PRODUCT_NAME} characters, got ${brand.productName.length}` };
-  }
-  if (brand.presetName.length === 0)
-    return { ok: false, reason: "brand.presetName: expected a non-empty preset name" };
-  for (const rule of FIELD_RULES) {
-    const value = brand[rule.field];
-    if (!rule.re.test(value))
-      return { ok: false, reason: `brand.${rule.field}: ${JSON.stringify(value)} is not ${rule.shape}` };
-  }
-  if (!isHttpsUrl(brand.contactUrl)) {
-    return {
-      ok: false,
-      reason: `brand.contactUrl: ${JSON.stringify(brand.contactUrl)} is not an https:// URL — it is published to vendors in identity headers as the way to reach whoever runs this client`
-    };
-  }
-  if (FIRST_PARTY_ORIGINATORS.includes(brand.codexOriginator)) {
-    return {
-      ok: false,
-      reason: `brand.codexOriginator: ${JSON.stringify(brand.codexOriginator)} is a first-party value. ` + `The originator field names the CLIENT, and sending a vendor's own name presents this software as that vendor's tool — ` + `supply your own token instead (one of: ${FIRST_PARTY_ORIGINATORS.join(", ")} is never it).`
-    };
-  }
-  return { ok: true, brand };
-}
-function envName(brand, suffix) {
-  return `${brand.envPrefix}${suffix}`;
-}
-function mcpToolName(brand, tool) {
-  return `mcp__${brand.mcpServerName}__${tool}`;
-}
-function userAgent(brand, version) {
-  return `${brand.packageName}/${version}`;
-}
-
 // src/options.ts
 var SYSTEM_PROMPT_DYNAMIC_BOUNDARY = "__SYSTEM_PROMPT_DYNAMIC_BOUNDARY__";
 var DEFAULT_CONTEXT_WINDOW_TOKENS = 200000;
 var DEFAULT_COMPACTION_THRESHOLD = 0.92;
-var DEFAULT_PLANS_DIRECTORY = `${WINTER_BRAND.projectDirName}/plans`;
+var DEFAULT_PLANS_DIRECTORY = `${WINTER_BRAND2.projectDirName}/plans`;
 var DEFAULT_OUTPUT_STYLE = "default";
 var DEFAULT_PROVIDER_STALL_TIMEOUT_MS = 120000;
-var DEFAULT_KEYCHAIN_SERVICE = WINTER_BRAND.keychainService;
+var DEFAULT_KEYCHAIN_SERVICE = WINTER_BRAND2.keychainService;
 function isWinterMcpServerInstance(value) {
   if (typeof value !== "object" || value === null)
     return false;
@@ -323,30 +240,132 @@ function defaultSpawn(opts) {
   };
 }
 
-// src/paths/home.ts
-import { homedir } from "node:os";
-import { join as join2 } from "node:path";
-function isUnset(value) {
-  return value === undefined || value.trim() === "";
-}
-function resolveWinterHome(env, brand) {
-  const b = brand ?? WINTER_BRAND;
-  const e = env ?? process.env;
-  const override = e[envName(b, "HOME")];
-  if (!isUnset(override))
-    return override;
-  const profile = e[envName(b, "PROFILE")];
-  const dirName = profile !== undefined && profile.trim() === "dev" ? `${b.homeDirName}-dev` : b.homeDirName;
-  return join2(homedir(), dirName);
-}
-function resolveKeychainServiceForProfile(brand, env, hostSetKeychainService) {
-  if (hostSetKeychainService)
-    return brand.keychainService;
-  const profile = (env ?? process.env)[envName(brand, "PROFILE")];
-  if (profile === undefined || profile.trim() !== "dev")
-    return brand.keychainService;
-  const suffixed = `${brand.keychainService}.dev`;
-  return suffixed.length <= 64 ? suffixed : brand.keychainService;
+// src/protocol/messaging.ts
+var MESSAGING_CONTROL_SUBTYPES = {
+  listReachable: "messaging.list_reachable",
+  deliver: "messaging.deliver",
+  steerChild: "messaging.steer_child",
+  resumeChild: "messaging.resume_child",
+  subscribeIdle: "messaging.subscribe_idle",
+  senderClass: "messaging.sender_class",
+  readNotifications: "messaging.read_notifications",
+  idleNotice: "messaging.idle_notice"
+};
+var MESSAGING_HOST_REQUEST_SUBTYPES = [
+  MESSAGING_CONTROL_SUBTYPES.listReachable,
+  MESSAGING_CONTROL_SUBTYPES.deliver,
+  MESSAGING_CONTROL_SUBTYPES.steerChild,
+  MESSAGING_CONTROL_SUBTYPES.resumeChild,
+  MESSAGING_CONTROL_SUBTYPES.subscribeIdle,
+  MESSAGING_CONTROL_SUBTYPES.senderClass,
+  MESSAGING_CONTROL_SUBTYPES.readNotifications
+];
+var MESSAGING_RUNTIME_REQUEST_SUBTYPES = [MESSAGING_CONTROL_SUBTYPES.idleNotice];
+var MESSAGING_CONTROL_SUBTYPE_LIST = Object.values(MESSAGING_CONTROL_SUBTYPES);
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var RUNTIME_OBJECT_KINDS = ["session", "agent"];
+var RUNTIME_KINDS = ["claude-agent", "winter-agent"];
+var PERMISSION_CLASS_LABELS = ["prompts", "bypasses", "unknown"];
+var DELIVERY_STATUSES = [
+  "delivered",
+  "queued",
+  "resumed_and_delivered",
+  "held",
+  "subscribed",
+  "delivery_uncertain",
+  "refused",
+  "ambiguous",
+  "not_found",
+  "unavailable"
+];
+function isRuntimeAddress(v) {
+  if (!isRecord(v))
+    return false;
+  if (!RUNTIME_OBJECT_KINDS.includes(v.objectKind))
+    return false;
+  if (!RUNTIME_KINDS.includes(v.runtimeKind))
+    return false;
+  if (typeof v.winterSessionId !== "string" || v.winterSessionId.length === 0)
+    return false;
+  if (v.objectKind === "agent" && (typeof v.childId !== "string" || v.childId.length === 0))
+    return false;
+  return true;
+}
+function isGlobalAgentMessage(v) {
+  if (!isRecord(v))
+    return false;
+  if (typeof v.messageId !== "string" || v.messageId.length === 0)
+    return false;
+  if (!isRuntimeAddress(v.from) || !isRuntimeAddress(v.to))
+    return false;
+  if (typeof v.body !== "string")
+    return false;
+  if (typeof v.notifyWhenIdle !== "boolean")
+    return false;
+  if (typeof v.hopCount !== "number")
+    return false;
+  if (!PERMISSION_CLASS_LABELS.includes(v.senderPermissionClass))
+    return false;
+  return true;
+}
+function isDeliveryOutcome(v) {
+  if (!isRecord(v))
+    return false;
+  if (!DELIVERY_STATUSES.includes(v.status))
+    return false;
+  if (typeof v.messageId !== "string")
+    return false;
+  if (v.status === "ambiguous" && !Array.isArray(v.candidates))
+    return false;
+  if (v.status === "unavailable" && typeof v.retryable !== "boolean")
+    return false;
+  return true;
+}
+function isListedRuntimeObjectArray(v) {
+  return Array.isArray(v) && v.every((row) => isRecord(row) && typeof row.address === "string" && RUNTIME_OBJECT_KINDS.includes(row.objectKind) && isRecord(row.capabilities));
+}
+function isPermissionClassLabel(v) {
+  return typeof v === "string" && PERMISSION_CLASS_LABELS.includes(v);
+}
+function isMessagingDeliverRequest(v) {
+  return isRecord(v) && isGlobalAgentMessage(v.message);
+}
+function isMessagingChildRequest(v) {
+  return isRecord(v) && typeof v.id === "string" && v.id.length > 0 && isGlobalAgentMessage(v.message);
+}
+function isNotificationRecord(v) {
+  return isRecord(v) && typeof v.notification_id === "string" && typeof v.origin === "string" && typeof v.queued_at === "string" && typeof v.content === "string";
+}
+function isMessagingNotificationsPage(v) {
+  return isRecord(v) && Array.isArray(v.notifications) && v.notifications.every(isNotificationRecord) && typeof v.remaining === "number";
+}
+function isMessagingIdleNoticePayload(v) {
+  return isRecord(v) && typeof v.subscriberSessionId === "string" && isNotificationRecord(v.notice);
+}
+function isMessagingReadNotificationsRequest(v) {
+  if (!isRecord(v))
+    return false;
+  if (v.subscriberSessionId !== undefined && typeof v.subscriberSessionId !== "string")
+    return false;
+  if (v.max !== undefined && (typeof v.max !== "number" || !Number.isFinite(v.max) || v.max < 0))
+    return false;
+  return true;
+}
+function isMessagingSubscribeIdleRequest(v) {
+  if (!isRecord(v))
+    return false;
+  if (typeof v.id !== "string" || v.id.length === 0)
+    return false;
+  if (typeof v.messageId !== "string" || v.messageId.length === 0)
+    return false;
+  if (v.subscriberSessionId !== undefined && typeof v.subscriberSessionId !== "string")
+    return false;
+  return true;
+}
+function resolveFacetTarget(sessionId, id, parse, buildChild) {
+  return parse(id) ?? buildChild(sessionId, id);
 }
 
 // src/query.ts
@@ -503,7 +522,7 @@ function query(args) {
     }
   }
   if (options.sessionStore !== undefined && options.persistSession === false) {
-    const homeVar = envName({ envPrefix: options.brand?.envPrefix ?? WINTER_BRAND.envPrefix }, "HOME");
+    const homeVar = envName2({ envPrefix: options.brand?.envPrefix ?? WINTER_BRAND2.envPrefix }, "HOME");
     throw new Error(`sessionStore cannot be used with persistSession: false -- the storage adapter requires local writes to mirror from. Use ${homeVar}=/tmp for ephemeral local writes with external mirroring.`);
   }
   if (options.sessionStore !== undefined && options.enableFileCheckpointing === true) {
@@ -512,7 +531,7 @@ function query(args) {
   if (options.keychainService !== undefined && options.brand?.keychainService !== undefined && options.brand.keychainService !== options.keychainService) {
     console.error(`winter: both 'keychainService' (${options.keychainService}) and 'brand.keychainService' (${options.brand.keychainService}) are set and differ — ` + `the deprecated 'keychainService' option wins. Set only 'brand.keychainService'.`);
   }
-  const brandResolution = resolveBrand({
+  const brandResolution = resolveBrand2({
     ...options.brand,
     ...options.keychainService !== undefined ? { keychainService: options.keychainService } : {}
   });
@@ -521,7 +540,7 @@ function query(args) {
   const hostSetKeychainService = options.brand?.keychainService !== undefined || options.keychainService !== undefined;
   const brand = {
     ...brandResolution.brand,
-    keychainService: resolveKeychainServiceForProfile(brandResolution.brand, options.env, hostSetKeychainService)
+    keychainService: resolveKeychainServiceForProfile2(brandResolution.brand, options.env, hostSetKeychainService)
   };
   const runtimeHooksConfig = buildRuntimeHooksConfig(options.hooks);
   const wireMcpServers = toWireMcpServers(options.mcpServers);
@@ -577,7 +596,7 @@ function query(args) {
     ...options.includePartialMessages !== undefined ? { includePartialMessages: options.includePartialMessages } : {},
     ...options.maxBudgetUsd !== undefined ? { maxBudgetUsd: options.maxBudgetUsd } : {},
     ...options.providerStallTimeoutMs !== undefined ? { providerStallTimeoutMs: options.providerStallTimeoutMs } : {},
-    ...brand.keychainService !== WINTER_BRAND.keychainService || options.keychainService !== undefined ? { keychainService: brand.keychainService } : {},
+    ...brand.keychainService !== WINTER_BRAND2.keychainService || options.keychainService !== undefined ? { keychainService: brand.keychainService } : {},
     ...options.autoClassifier !== undefined ? { autoClassifier: options.autoClassifier } : {},
     ...options.advisor !== undefined ? { advisor: options.advisor } : {},
     brand
@@ -819,6 +838,7 @@ function query(args) {
       }
     }
   }
+  const idleNoticeHandlers = new Set;
   const gen = iterate();
   gen.interrupt = async () => {
     await sendControlRequest("interrupt", { scope: "turn" });
@@ -841,6 +861,85 @@ function query(args) {
   gen.setPermissionMode = async (mode) => {
     await sendControlRequest("set_permission_mode", mode);
   };
+  async function deliveryCall(subtype, payload, messageId) {
+    let answer;
+    try {
+      answer = await sendControlRequest(subtype, payload);
+    } catch (err) {
+      const code = err instanceof WinterRpcError ? err.code : "";
+      const message = err instanceof Error ? err.message : String(err);
+      if (code === "invalid_messaging_request")
+        return refused2(messageId, message);
+      if (code === "messaging_unavailable")
+        return unavailable2(messageId, false, message);
+      return deliveryUncertain2(messageId, `'${subtype}' failed: ${message}`);
+    }
+    return isDeliveryOutcome(answer) ? answer : deliveryUncertain2(messageId, `the runtime returned a malformed delivery outcome for '${subtype}'`);
+  }
+  gen.messaging = {
+    async listReachable() {
+      const payload = await sendControlRequest(MESSAGING_CONTROL_SUBTYPES.listReachable, undefined).catch(() => {
+        return;
+      });
+      return isListedRuntimeObjectArray(payload) ? payload : [];
+    },
+    deliver(msg) {
+      const request = { message: msg };
+      return deliveryCall(MESSAGING_CONTROL_SUBTYPES.deliver, request, msg.messageId);
+    },
+    steerChild(id, msg) {
+      const request = { id, message: msg };
+      return deliveryCall(MESSAGING_CONTROL_SUBTYPES.steerChild, request, msg.messageId);
+    },
+    resumeChild(id, msg) {
+      const request = { id, message: msg };
+      return deliveryCall(MESSAGING_CONTROL_SUBTYPES.resumeChild, request, msg.messageId);
+    },
+    subscribeIdle(id, opts) {
+      const request = {
+        id,
+        messageId: opts.messageId,
+        ...opts.subscriberSessionId !== undefined ? { subscriberSessionId: opts.subscriberSessionId } : {}
+      };
+      return deliveryCall(MESSAGING_CONTROL_SUBTYPES.subscribeIdle, request, opts.messageId);
+    },
+    async senderClass() {
+      const payload = await sendControlRequest(MESSAGING_CONTROL_SUBTYPES.senderClass, undefined).catch(() => {
+        return;
+      });
+      const label = typeof payload === "object" && payload !== null ? payload.senderClass : undefined;
+      return isPermissionClassLabel(label) ? label : "unknown";
+    },
+    async readNotifications(opts) {
+      const request = {
+        ...opts?.subscriberSessionId !== undefined ? { subscriberSessionId: opts.subscriberSessionId } : {},
+        ...opts?.max !== undefined ? { max: opts.max } : {}
+      };
+      const payload = await sendControlRequest(MESSAGING_CONTROL_SUBTYPES.readNotifications, request).catch(() => {
+        return;
+      });
+      return isMessagingNotificationsPage(payload) ? payload : { notifications: [], remaining: 0 };
+    },
+    onIdleNotice(handler) {
+      idleNoticeHandlers.add(handler);
+      return () => {
+        idleNoticeHandlers.delete(handler);
+      };
+    }
+  };
+  controlRequestHandlers.set(MESSAGING_CONTROL_SUBTYPES.idleNotice, async (payload) => {
+    if (!isMessagingIdleNoticePayload(payload)) {
+      return { ok: false, error: { code: "invalid_idle_notice", message: "messaging.idle_notice requires { subscriberSessionId: string, notice: NotificationRecord }" } };
+    }
+    for (const handler of [...idleNoticeHandlers]) {
+      try {
+        handler(payload);
+      } catch (err) {
+        console.error(`winter: onIdleNotice handler threw for notification ${payload.notice.notification_id}: ${err instanceof Error ? err.message : String(err)} -- the notice is still queued for readNotifications()`);
+      }
+    }
+    return { ok: true, payload: { delivered: idleNoticeHandlers.size } };
+  });
   gen.rewindFiles = async (userMessageId, options) => {
     const payload = await sendControlRequest("rewind_files", { user_message_id: userMessageId, ...options?.dryRun !== undefined ? { dry_run: options.dryRun } : {} });
     if (typeof payload !== "object" || payload === null || typeof payload.canRewind !== "boolean") {
@@ -861,8 +960,14 @@ function query(args) {
   };
   return gen;
 }
+// src/version.ts
+var SDK_VERSION = "0.0.3";
 // src/paths/project-key.ts
-var MAX_UNSUFFIXED_LENGTH = 200;
+var TRANSCRIPT_PROJECT_KEY_MAX_LENGTH = 64;
+var VENDOR_PROJECT_KEY_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+function isVendorCompliantProjectKey(key) {
+  return VENDOR_PROJECT_KEY_PATTERN.test(key);
+}
 function sanitize(absPath) {
   return absPath.replace(/[^a-zA-Z0-9]/g, "-");
 }
@@ -878,9 +983,10 @@ function overflowSuffix(rawAbsPath) {
 }
 function transcriptProjectKey(absPath) {
   const sanitized = sanitize(absPath);
-  if (sanitized.length <= MAX_UNSUFFIXED_LENGTH)
+  if (sanitized.length <= TRANSCRIPT_PROJECT_KEY_MAX_LENGTH)
     return sanitized;
-  return `${sanitized.slice(0, MAX_UNSUFFIXED_LENGTH)}-${overflowSuffix(absPath)}`;
+  const suffix = overflowSuffix(absPath);
+  return sanitized.slice(0, TRANSCRIPT_PROJECT_KEY_MAX_LENGTH - 1 - suffix.length) + "-" + suffix;
 }
 // src/paths/keys.ts
 import { realpathSync } from "node:fs";
@@ -916,590 +1022,15 @@ function compatibilityKeys(cwd) {
   const memoryKey = commonRoot === null ? cwdKey : transcriptProjectKey(commonRoot);
   return { transcriptProjectKey: cwdKey, memoryProjectKey: memoryKey, tempProjectKey: cwdKey };
 }
-// src/store/session-store.ts
-import {
-  mkdirSync,
-  lstatSync,
-  chmodSync,
-  readdirSync,
-  readFileSync as readFileSync2,
-  statSync,
-  openSync as openSync2,
-  fsyncSync as fsyncSync2,
-  closeSync as closeSync2,
-  renameSync as renameSync2,
-  rmSync,
-  ftruncateSync,
-  constants as fsConstants
-} from "node:fs";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { join as join3 } from "node:path";
-
-// src/store/leases.ts
-import { openSync, readFileSync, writeSync, fsyncSync, closeSync, renameSync, linkSync, unlinkSync } from "node:fs";
-
-class WinterStoreError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "WinterStoreError";
-  }
-}
-
-class WinterStoreLeaseError extends WinterStoreError {
-  heldByPid;
-  constructor(message, heldByPid) {
-    super(message);
-    this.heldByPid = heldByPid;
-    this.name = "WinterStoreLeaseError";
-  }
-}
-function isPidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    const code = err.code;
-    if (code === "ESRCH")
-      return false;
-    if (code === "EPERM")
-      return true;
-    throw err;
-  }
-}
-function writeAllSync(fd, buf) {
-  let written = 0;
-  while (written < buf.length) {
-    written += writeSync(fd, buf, written, buf.length - written);
-  }
-}
-function readLeaseInfo(lockPath) {
-  let raw;
-  try {
-    raw = readFileSync(lockPath, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT")
-      return null;
-    throw err;
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed.pid === "number" && typeof parsed.startTimeMs === "number") {
-      return { pid: parsed.pid, startTimeMs: parsed.startTimeMs };
-    }
-  } catch {}
-  return null;
-}
-function createExclusive(lockPath, info) {
-  const data = Buffer.from(JSON.stringify(info), "utf8");
-  const tmpPath = `${lockPath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  const fd = openSync(tmpPath, "wx", 384);
-  try {
-    writeAllSync(fd, data);
-    fsyncSync(fd);
-  } finally {
-    closeSync(fd);
-  }
-  try {
-    linkSync(tmpPath, lockPath);
-  } finally {
-    try {
-      unlinkSync(tmpPath);
-    } catch (err) {
-      if (err.code !== "ENOENT")
-        throw err;
-    }
-  }
-}
-function writeLeaseInfoReplacing(lockPath, info) {
-  const data = Buffer.from(JSON.stringify(info), "utf8");
-  const tmpPath = `${lockPath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  const fd = openSync(tmpPath, "wx", 384);
-  try {
-    writeAllSync(fd, data);
-    fsyncSync(fd);
-  } finally {
-    closeSync(fd);
-  }
-  renameSync(tmpPath, lockPath);
-}
-function acquireLease(lockPath) {
-  const fresh = { pid: process.pid, startTimeMs: Date.now() };
-  try {
-    createExclusive(lockPath, fresh);
-    return fresh;
-  } catch (err) {
-    if (err.code !== "EEXIST")
-      throw err;
-  }
-  const existing = readLeaseInfo(lockPath);
-  if (existing !== null && existing.pid === process.pid) {
-    return existing;
-  }
-  if (existing !== null && isPidAlive(existing.pid)) {
-    throw new WinterStoreLeaseError(`session lease is held by another live process (pid ${existing.pid}); refusing a concurrent writer`, existing.pid);
-  }
-  writeLeaseInfoReplacing(lockPath, fresh);
-  return fresh;
-}
-
-// src/store/session-store.ts
-var DIALECT_RECORD_ENTRY_TYPE = "winter_dialect_record";
-var PROVIDER_STATE_FILE_SUFFIX = ".provider-state.jsonl";
-function assertSafeSingleSegment(value, label) {
-  if (value === "")
-    throw new WinterStoreError(`${label} must not be empty`);
-  if (value.includes("/"))
-    throw new WinterStoreError(`${label} must not contain a path separator: ${JSON.stringify(value)}`);
-  if (value === "." || value === "..")
-    throw new WinterStoreError(`${label} must not be a traversal segment: ${JSON.stringify(value)}`);
-}
-function assertSafeSubpath(value) {
-  if (value === "")
-    throw new WinterStoreError("subpath must not be empty");
-  if (value.startsWith("/"))
-    throw new WinterStoreError(`subpath must not be absolute: ${JSON.stringify(value)}`);
-  const segments = value.split("/");
-  for (const segment of segments) {
-    if (segment === "") {
-      throw new WinterStoreError(`subpath must not contain empty segments (double/trailing separators): ${JSON.stringify(value)}`);
-    }
-    if (segment === "." || segment === "..") {
-      throw new WinterStoreError(`subpath must not contain a traversal segment: ${JSON.stringify(value)}`);
-    }
-  }
-  return segments;
-}
-function projectDir(winterHome, projectKey) {
-  return join3(winterHome, "projects", projectKey);
-}
-function sessionStem(winterHome, projectKey, sessionId) {
-  assertSafeSingleSegment(projectKey, "projectKey");
-  assertSafeSingleSegment(sessionId, "sessionId");
-  return join3(projectDir(winterHome, projectKey), sessionId);
-}
-function locateResource(winterHome, key) {
-  assertSafeSingleSegment(key.projectKey, "projectKey");
-  assertSafeSingleSegment(key.sessionId, "sessionId");
-  const projDir = projectDir(winterHome, key.projectKey);
-  const dirLevels = [winterHome, join3(winterHome, "projects"), projDir];
-  if (key.subpath === undefined) {
-    return { dirLevels, stem: join3(projDir, key.sessionId) };
-  }
-  const segments = assertSafeSubpath(key.subpath);
-  let current = join3(projDir, key.sessionId);
-  dirLevels.push(current);
-  for (let i = 0;i < segments.length - 1; i++) {
-    current = join3(current, segments[i]);
-    dirLevels.push(current);
-  }
-  const stem = join3(current, segments[segments.length - 1]);
-  return { dirLevels, stem };
-}
-function realUid() {
-  return process.getuid();
-}
-function ensureSecureDir(path) {
-  try {
-    mkdirSync(path, { mode: 448 });
-  } catch (err) {
-    if (err.code !== "EEXIST")
-      throw err;
-  }
-  const stat = lstatSync(path);
-  if (stat.isSymbolicLink())
-    throw new WinterStoreError(`refusing a symlink at a level the store must own: ${path}`);
-  if (!stat.isDirectory())
-    throw new WinterStoreError(`expected a directory, found something else at: ${path}`);
-  if (stat.uid !== realUid())
-    throw new WinterStoreError(`refusing a directory owned by a different uid: ${path}`);
-  chmodSync(path, 448);
-}
-var APPEND_FLAGS = fsConstants.O_WRONLY | fsConstants.O_APPEND | fsConstants.O_CREAT | fsConstants.O_NOFOLLOW;
-var RW_EXISTING_FLAGS = fsConstants.O_RDWR | fsConstants.O_NOFOLLOW;
-function appendLinesAtomically(path, lines) {
-  const data = Buffer.from(lines.map((l) => l + `
-`).join(""), "utf8");
-  const fd = openSync2(path, APPEND_FLAGS, 384);
-  try {
-    writeAllSync(fd, data);
-    fsyncSync2(fd);
-  } finally {
-    closeSync2(fd);
-  }
-  chmodSync(path, 384);
-}
-function quarantineTornTail(jsonlPath, tornRaw) {
-  const quarantinePath = `${jsonlPath}.tail-quarantine`;
-  const fd = openSync2(quarantinePath, APPEND_FLAGS, 384);
-  try {
-    writeAllSync(fd, tornRaw);
-    fsyncSync2(fd);
-  } finally {
-    closeSync2(fd);
-  }
-  chmodSync(quarantinePath, 384);
-}
-function repairTruncate(jsonlPath, keepBytes) {
-  const fd = openSync2(jsonlPath, RW_EXISTING_FLAGS);
-  try {
-    ftruncateSync(fd, keepBytes);
-    fsyncSync2(fd);
-  } finally {
-    closeSync2(fd);
-  }
-}
-function writeJsonAtomically(path, value) {
-  const data = Buffer.from(JSON.stringify(value), "utf8");
-  const tmpPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  const fd = openSync2(tmpPath, "wx", 384);
-  try {
-    writeAllSync(fd, data);
-    fsyncSync2(fd);
-  } finally {
-    closeSync2(fd);
-  }
-  renameSync2(tmpPath, path);
-  chmodSync(path, 384);
-}
-function readJsonIfExists(path) {
-  let raw;
-  try {
-    raw = readFileSync2(path, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT")
-      return null;
-    throw err;
-  }
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function rmIfExists(path) {
-  try {
-    rmSync(path);
-  } catch (err) {
-    if (err.code !== "ENOENT")
-      throw err;
-  }
-}
-var NEWLINE = 10;
-function isParseableJson(text) {
-  try {
-    JSON.parse(text);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function decodeCompleteLines(buf) {
-  if (buf.length === 0)
-    return [];
-  const lines = buf.toString("utf8").split(`
-`);
-  lines.pop();
-  return lines.map((line) => JSON.parse(line));
-}
-function parseWithTailRepair(buf) {
-  if (buf.length === 0)
-    return { entries: [], torn: null };
-  const endsWithNewline = buf[buf.length - 1] === NEWLINE;
-  if (endsWithNewline) {
-    const searchEnd = buf.length - 2;
-    const prevNL = searchEnd < 0 ? -1 : buf.lastIndexOf(NEWLINE, searchEnd);
-    const lastLineStart = prevNL + 1;
-    const lastLine = buf.subarray(lastLineStart, buf.length - 1).toString("utf8");
-    if (isParseableJson(lastLine)) {
-      return { entries: decodeCompleteLines(buf), torn: null };
-    }
-    const keepBytes = lastLineStart;
-    const tornRaw = Buffer.from(buf.subarray(lastLineStart));
-    return { entries: decodeCompleteLines(buf.subarray(0, keepBytes)), torn: { raw: tornRaw, keepBytes } };
-  }
-  const lastNL = buf.lastIndexOf(NEWLINE);
-  const keepBytes = lastNL + 1;
-  const tornRaw = Buffer.from(buf.subarray(keepBytes));
-  return { entries: decodeCompleteLines(buf.subarray(0, keepBytes)), torn: { raw: tornRaw, keepBytes } };
-}
-function hasLiveForeignLeaseHolder(lockPath) {
-  const lease = readLeaseInfo(lockPath);
-  return lease !== null && lease.pid !== process.pid && isPidAlive(lease.pid);
-}
-function walkResourceStems(dir, prefix, out) {
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch (err) {
-    if (err.code === "ENOENT")
-      return;
-    throw err;
-  }
-  for (const dirent of entries) {
-    const relPath = prefix === "" ? dirent.name : `${prefix}/${dirent.name}`;
-    if (dirent.isDirectory()) {
-      walkResourceStems(join3(dir, dirent.name), relPath, out);
-    } else if (dirent.isFile() && dirent.name.endsWith(".jsonl")) {
-      out.add(relPath.slice(0, -".jsonl".length));
-    } else if (dirent.isFile() && dirent.name.endsWith(".meta.json")) {
-      out.add(relPath.slice(0, -".meta.json".length));
-    }
-  }
-}
-function foldSummary(summaryPath, sessionId, newEntries, dialectExtra) {
-  const previous = readJsonIfExists(summaryPath) ?? {};
-  const mechanical = {};
-  if (newEntries.length > 0) {
-    const lastEntry = newEntries[newEntries.length - 1];
-    mechanical.entryCount = (previous.entryCount ?? 0) + newEntries.length;
-    mechanical.lastEntryType = lastEntry.type;
-    if (lastEntry.timestamp !== undefined)
-      mechanical.lastTimestamp = lastEntry.timestamp;
-  }
-  const updated = {
-    ...previous,
-    ...dialectExtra,
-    sessionId,
-    ...mechanical,
-    mtime: Date.now()
-  };
-  writeJsonAtomically(summaryPath, updated);
-}
-
-class WinterCompatibilitySessionStore {
-  winterHome;
-  constructor(opts) {
-    this.winterHome = opts.winterHome;
-  }
-  async append(key, entries) {
-    if (entries.length === 0)
-      return;
-    const { dirLevels, stem } = locateResource(this.winterHome, key);
-    for (const level of dirLevels)
-      ensureSecureDir(level);
-    const lockPath = `${sessionStem(this.winterHome, key.projectKey, key.sessionId)}.lock`;
-    acquireLease(lockPath);
-    chmodSync(lockPath, 384);
-    const jsonlPath = `${stem}.jsonl`;
-    const metaPath = `${stem}.meta.json`;
-    const nativeEntries = [];
-    let latestMetadata;
-    let dialectExtra;
-    for (const e of entries) {
-      if (e.type === "agent_metadata") {
-        latestMetadata = e;
-      } else if (e.type === DIALECT_RECORD_ENTRY_TYPE) {
-        const { type: _type, ...fields } = e;
-        dialectExtra = fields;
-      } else {
-        nativeEntries.push(e);
-      }
-    }
-    if (nativeEntries.length > 0) {
-      appendLinesAtomically(jsonlPath, nativeEntries.map((e) => JSON.stringify(e)));
-    }
-    if (latestMetadata !== undefined) {
-      writeJsonAtomically(metaPath, latestMetadata);
-    }
-    if (key.subpath === undefined && (nativeEntries.length > 0 || dialectExtra !== undefined)) {
-      foldSummary(`${sessionStem(this.winterHome, key.projectKey, key.sessionId)}.summary.json`, key.sessionId, nativeEntries, dialectExtra);
-    }
-  }
-  async load(key) {
-    const { stem } = locateResource(this.winterHome, key);
-    const jsonlPath = `${stem}.jsonl`;
-    const metaPath = `${stem}.meta.json`;
-    let raw;
-    try {
-      raw = readFileSync2(jsonlPath);
-    } catch (err) {
-      if (err.code !== "ENOENT")
-        throw err;
-      raw = null;
-    }
-    if (raw === null) {
-      const meta = readJsonIfExists(metaPath);
-      return meta === null ? null : [meta];
-    }
-    const { entries, torn } = parseWithTailRepair(raw);
-    if (torn !== null) {
-      const lockPath = `${sessionStem(this.winterHome, key.projectKey, key.sessionId)}.lock`;
-      if (!hasLiveForeignLeaseHolder(lockPath)) {
-        quarantineTornTail(jsonlPath, torn.raw);
-        repairTruncate(jsonlPath, torn.keepBytes);
-      }
-    }
-    const meta = readJsonIfExists(metaPath);
-    if (meta !== null)
-      entries.push(meta);
-    return entries;
-  }
-  async listSessions(projectKey) {
-    assertSafeSingleSegment(projectKey, "projectKey");
-    const dir = projectDir(this.winterHome, projectKey);
-    let names;
-    try {
-      names = readdirSync(dir);
-    } catch (err) {
-      if (err.code === "ENOENT")
-        return [];
-      throw err;
-    }
-    const result = [];
-    const seenSessionIds = new Set;
-    for (const name of names) {
-      if (!name.endsWith(".jsonl"))
-        continue;
-      const full = join3(dir, name);
-      const stat = statSync(full);
-      if (!stat.isFile())
-        continue;
-      const sessionId = name.slice(0, -".jsonl".length);
-      seenSessionIds.add(sessionId);
-      result.push({ sessionId, mtime: stat.mtimeMs });
-    }
-    for (const name of names) {
-      if (!name.endsWith(".meta.json"))
-        continue;
-      const sessionId = name.slice(0, -".meta.json".length);
-      if (seenSessionIds.has(sessionId))
-        continue;
-      const full = join3(dir, name);
-      const stat = statSync(full);
-      if (!stat.isFile())
-        continue;
-      seenSessionIds.add(sessionId);
-      result.push({ sessionId, mtime: stat.mtimeMs });
-    }
-    return result;
-  }
-  async listSessionSummaries(projectKey) {
-    assertSafeSingleSegment(projectKey, "projectKey");
-    const dir = projectDir(this.winterHome, projectKey);
-    let names;
-    try {
-      names = readdirSync(dir);
-    } catch (err) {
-      if (err.code === "ENOENT")
-        return [];
-      throw err;
-    }
-    const result = [];
-    for (const name of names) {
-      if (!name.endsWith(".summary.json"))
-        continue;
-      const parsed = readJsonIfExists(join3(dir, name));
-      if (parsed !== null)
-        result.push(parsed);
-    }
-    return result;
-  }
-  async delete(key) {
-    const { stem } = locateResource(this.winterHome, key);
-    if (key.subpath === undefined) {
-      rmIfExists(`${stem}.jsonl`);
-      rmIfExists(`${stem}.jsonl.tail-quarantine`);
-      rmIfExists(`${stem}.lock`);
-      rmIfExists(`${stem}.summary.json`);
-      rmIfExists(`${stem}.meta.json`);
-      rmIfExists(`${stem}${PROVIDER_STATE_FILE_SUFFIX}`);
-      rmSync(stem, { recursive: true, force: true });
-    } else {
-      rmIfExists(`${stem}.jsonl`);
-      rmIfExists(`${stem}.jsonl.tail-quarantine`);
-      rmIfExists(`${stem}.meta.json`);
-      rmIfExists(`${stem}${PROVIDER_STATE_FILE_SUFFIX}`);
-    }
-  }
-  async listSubkeys(key) {
-    const sessionDir = sessionStem(this.winterHome, key.projectKey, key.sessionId);
-    const results = new Set;
-    walkResourceStems(sessionDir, "", results);
-    return [...results];
-  }
-  async listProjectKeys() {
-    const dir = join3(this.winterHome, "projects");
-    let entries;
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch (err) {
-      if (err.code === "ENOENT")
-        return [];
-      throw err;
-    }
-    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-  }
-  async copyProviderStateForFork(src, dest) {
-    const { stem: srcStem } = locateResource(this.winterHome, src);
-    const { stem: destStem, dirLevels } = locateResource(this.winterHome, dest);
-    let raw;
-    try {
-      raw = readFileSync2(`${srcStem}${PROVIDER_STATE_FILE_SUFFIX}`, "utf8");
-    } catch (err) {
-      if (err.code === "ENOENT")
-        return 0;
-      throw err;
-    }
-    const lines = [];
-    for (const line of raw.split(`
-`)) {
-      if (line.length === 0)
-        continue;
-      let record;
-      try {
-        record = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (typeof record !== "object" || record === null || Array.isArray(record))
-        continue;
-      lines.push(JSON.stringify({ ...record, uuid: randomUUID2(), sessionId: dest.sessionId }));
-    }
-    if (lines.length === 0)
-      return 0;
-    for (const level of dirLevels)
-      ensureSecureDir(level);
-    appendLinesAtomically(`${destStem}${PROVIDER_STATE_FILE_SUFFIX}`, lines);
-    return lines.length;
-  }
-  async readSessionSummary(key) {
-    assertSafeSingleSegment(key.projectKey, "projectKey");
-    assertSafeSingleSegment(key.sessionId, "sessionId");
-    return readJsonIfExists(`${sessionStem(this.winterHome, key.projectKey, key.sessionId)}.summary.json`);
-  }
-  async mergeSessionMetadata(key, patch) {
-    const stem = sessionStem(this.winterHome, key.projectKey, key.sessionId);
-    const lockPath = `${stem}.lock`;
-    acquireLease(lockPath);
-    chmodSync(lockPath, 384);
-    const summaryPath = `${stem}.summary.json`;
-    const previous = readJsonIfExists(summaryPath) ?? {};
-    const updated = {
-      ...previous,
-      ...patch,
-      sessionId: key.sessionId,
-      mtime: Date.now()
-    };
-    writeJsonAtomically(summaryPath, updated);
-  }
-  async acquireSessionLease(key) {
-    const { dirLevels } = locateResource(this.winterHome, key);
-    for (const level of dirLevels)
-      ensureSecureDir(level);
-    const lockPath = `${sessionStem(this.winterHome, key.projectKey, key.sessionId)}.lock`;
-    acquireLease(lockPath);
-    chmodSync(lockPath, 384);
-  }
-}
 // src/store/fork-session.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 var IDENTITY_FIELDS = ["providerId", "modelKey", "adapterId", "adapterVersion", "catalogVersion", "authRef", "classifierPin"];
 async function forkSessionByKey(store, src) {
   const entries = await store.load(src);
   if (entries === null) {
     throw new SessionNotFoundError("not_found", `forkSession: source session not found: ${JSON.stringify(src)}`);
   }
-  const newSessionId = randomUUID3();
+  const newSessionId = randomUUID2();
   const rewritten = entries.map((e) => typeof e.sessionId === "string" ? { ...e, sessionId: newSessionId } : e);
   const destKey = { projectKey: src.projectKey, sessionId: newSessionId, ...src.subpath !== undefined ? { subpath: src.subpath } : {} };
   await store.append(destKey, rewritten);
@@ -1508,7 +1039,7 @@ async function forkSessionByKey(store, src) {
     await carry.copyProviderStateForFork?.(src, destKey);
     const summary = destKey.subpath === undefined && carry.readSessionSummary !== undefined ? await carry.readSessionSummary({ projectKey: src.projectKey, sessionId: src.sessionId }) : null;
     if (summary !== null && typeof summary.providerId === "string" && typeof summary.modelKey === "string") {
-      const identity = { type: DIALECT_RECORD_ENTRY_TYPE };
+      const identity = { type: DIALECT_RECORD_ENTRY_TYPE2 };
       for (const field of IDENTITY_FIELDS) {
         const value = summary[field];
         if (typeof value === "string")
@@ -1524,14 +1055,14 @@ function resolveHome(winterHome, brand) {
   if (winterHome !== undefined)
     return winterHome;
   if (brand === undefined)
-    return resolveWinterHome();
-  const resolved = resolveBrand(brand);
+    return resolveWinterHome2();
+  const resolved = resolveBrand2(brand);
   if (!resolved.ok)
     throw new TypeError(`sessions: invalid brand profile -- ${resolved.reason}`);
-  return resolveWinterHome(undefined, resolved.brand);
+  return resolveWinterHome2(undefined, resolved.brand);
 }
 function openStore(opts) {
-  return new WinterCompatibilitySessionStore({ winterHome: resolveHome(opts?.winterHome, opts?.brand) });
+  return new WinterCompatibilitySessionStore2({ winterHome: resolveHome(opts?.winterHome, opts?.brand) });
 }
 async function findInProject(store, projectKey, sessionId) {
   const sessions = await store.listSessions(projectKey);
@@ -1646,16 +1177,16 @@ async function getSubagentMessages(sessionId, agentId, opts) {
 }
 // src/settings/sources.ts
 import { readFile } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { join as join2 } from "node:path";
 function settingsPathFor(source, opts) {
-  const brand = opts.brand ?? WINTER_BRAND;
+  const brand = opts.brand ?? WINTER_BRAND2;
   switch (source) {
     case "user":
-      return join4(opts.winterHome ?? resolveWinterHome(opts.env, brand), "settings.json");
+      return join2(opts.winterHome ?? resolveWinterHome2(opts.env, brand), "settings.json");
     case "project":
-      return join4(opts.cwd, brand.projectDirName, "settings.json");
+      return join2(opts.cwd, brand.projectDirName, "settings.json");
     case "local":
-      return join4(opts.cwd, brand.projectDirName, "settings.local.json");
+      return join2(opts.cwd, brand.projectDirName, "settings.local.json");
   }
 }
 function isPlainObject(v) {
@@ -2123,7 +1654,7 @@ var HOOK_EVENTS = [
 ];
 export {
   AbortError,
-  BRAND_TOKEN_RE,
+  BRAND_TOKEN_RE2 as BRAND_TOKEN_RE,
   CLIConnectionError,
   DEFAULT_COMPACTION_THRESHOLD,
   DEFAULT_CONTEXT_WINDOW_TOKENS,
@@ -2131,61 +1662,81 @@ export {
   DEFAULT_OUTPUT_STYLE,
   DEFAULT_PLANS_DIRECTORY,
   DEFAULT_PROVIDER_STALL_TIMEOUT_MS,
-  DIALECT_RECORD_ENTRY_TYPE,
+  DIALECT_RECORD_ENTRY_TYPE2 as DIALECT_RECORD_ENTRY_TYPE,
   ESCALATING_PERMISSION_MODES,
-  FIRST_PARTY_ORIGINATORS,
+  FIRST_PARTY_ORIGINATORS2 as FIRST_PARTY_ORIGINATORS,
   HOOK_EVENTS,
   InvalidBrandError,
+  MESSAGING_CONTROL_SUBTYPES,
+  MESSAGING_CONTROL_SUBTYPE_LIST,
+  MESSAGING_HOST_REQUEST_SUBTYPES,
+  MESSAGING_RUNTIME_REQUEST_SUBTYPES,
   OVERLAY_NEVER_KEYS,
   PROJECT_PERMISSIVE_KEYS,
   PROTOCOL_VERSION,
-  PROVIDER_STATE_FILE_SUFFIX,
+  PROVIDER_STATE_FILE_SUFFIX2 as PROVIDER_STATE_FILE_SUFFIX,
   ProcessError,
   ProtocolDecodeError,
   ProtocolError,
   ResultError,
+  SDK_VERSION,
   SETTING_SOURCES,
   SYSTEM_PROMPT_DYNAMIC_BOUNDARY,
   SessionNotFoundError,
-  WINTER_BRAND,
-  WinterCompatibilitySessionStore,
+  TRANSCRIPT_PROJECT_KEY_MAX_LENGTH,
+  WINTER_BRAND2 as WINTER_BRAND,
+  WinterCompatibilitySessionStore2 as WinterCompatibilitySessionStore,
   WinterRpcError,
   WinterRpcTimeoutError,
   WinterSDKError,
-  WinterStoreError,
-  WinterStoreLeaseError,
+  WinterStoreError2 as WinterStoreError,
+  WinterStoreLeaseError2 as WinterStoreLeaseError,
   applyWorkspaceTrust,
   compatibilityKeys,
   decodeFrame,
   defaultSpawn,
   deleteSession,
   encodeFrame,
-  envName,
+  envName2 as envName,
   filterEscalatingDefaultMode,
   forkSession,
   forkSessionByKey,
   getSessionInfo,
   getSessionMessages,
   getSubagentMessages,
-  isUnset,
+  isDeliveryOutcome,
+  isGlobalAgentMessage,
+  isListedRuntimeObjectArray,
+  isMessagingChildRequest,
+  isMessagingDeliverRequest,
+  isMessagingIdleNoticePayload,
+  isMessagingNotificationsPage,
+  isMessagingReadNotificationsRequest,
+  isMessagingSubscribeIdleRequest,
+  isNotificationRecord,
+  isPermissionClassLabel,
+  isRuntimeAddress,
+  isUnset2 as isUnset,
+  isVendorCompliantProjectKey,
   isWinterMcpServerInstance,
   listSessions,
   listSubagents,
   loadSettingsFile,
-  mcpToolName,
+  mcpToolName2 as mcpToolName,
   providerSettingsFrom,
   query,
   renameSession,
-  resolveBrand,
-  resolveKeychainServiceForProfile,
+  resolveBrand2 as resolveBrand,
+  resolveFacetTarget,
+  resolveKeychainServiceForProfile2 as resolveKeychainServiceForProfile,
   resolveRuntimeExecutable,
   resolveSettings,
   resolveSettingsDetailed,
-  resolveWinterHome,
+  resolveWinterHome2 as resolveWinterHome,
   settingsPathFor,
   splitFrames,
   tagSession,
   transcriptProjectKey,
-  userAgent,
+  userAgent2 as userAgent,
   validateModelSlots
 };