@yanlinglabs/winter-agent-sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,2191 @@
+// src/query.ts
+import { randomUUID } from "node:crypto";
+
+// src/protocol/frames.ts
+var PROTOCOL_VERSION = "1.0";
+
+// src/protocol/codec.ts
+class ProtocolError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProtocolError";
+  }
+}
+function encodeFrame(frame) {
+  return JSON.stringify(frame) + `
+`;
+}
+function decodeFrame(line) {
+  let v;
+  try {
+    v = JSON.parse(line);
+  } catch {
+    throw new ProtocolError(`malformed JSON frame: ${line.slice(0, 80)}`);
+  }
+  if (typeof v !== "object" || v === null || Array.isArray(v) || typeof v.type !== "string")
+    throw new ProtocolError("frame missing string 'type'");
+  return v;
+}
+function splitFrames(chunk, carry) {
+  const text = carry + chunk;
+  const parts = text.split(`
+`);
+  const nextCarry = parts.pop() ?? "";
+  const frames = parts.filter((l) => l.length > 0).map(decodeFrame);
+  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_OUTPUT_STYLE = "default";
+var DEFAULT_PROVIDER_STALL_TIMEOUT_MS = 120000;
+var DEFAULT_KEYCHAIN_SERVICE = WINTER_BRAND.keychainService;
+function isWinterMcpServerInstance(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const candidate = value;
+  return typeof candidate.listTools === "function" && typeof candidate.callTool === "function";
+}
+
+// src/transport.ts
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { spawn } from "node:child_process";
+
+// src/errors.ts
+class WinterSDKError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WinterSDKError";
+  }
+}
+
+class CLIConnectionError extends WinterSDKError {
+  constructor(message) {
+    super(message);
+    this.name = "CLIConnectionError";
+  }
+}
+
+class ProcessError extends WinterSDKError {
+  code;
+  signal;
+  constructor(message, code, signal) {
+    super(message);
+    this.code = code;
+    this.signal = signal;
+    this.name = "ProcessError";
+  }
+}
+
+class ResultError extends ProcessError {
+  result;
+  constructor(result) {
+    super(result.terminal_reason === "api_error" ? `provider request failed: ${result.result ?? "unknown provider error"}` : `result error: ${result.subtype}`);
+    this.result = result;
+    this.name = "ResultError";
+  }
+}
+
+class ProtocolDecodeError extends WinterSDKError {
+  constructor(message) {
+    super(message);
+    this.name = "ProtocolDecodeError";
+  }
+}
+
+class AbortError extends WinterSDKError {
+  constructor(message) {
+    super(message);
+    this.name = "AbortError";
+  }
+}
+
+class SessionNotFoundError extends WinterSDKError {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "SessionNotFoundError";
+    this.reason = reason;
+  }
+}
+
+class InvalidBrandError extends WinterSDKError {
+  reason;
+  code = "invalid_brand";
+  constructor(reason) {
+    super(`invalid_brand: ${reason}`);
+    this.reason = reason;
+    this.name = "InvalidBrandError";
+  }
+}
+
+class WinterRpcError extends WinterSDKError {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "WinterRpcError";
+  }
+}
+
+class WinterRpcTimeoutError extends WinterRpcError {
+  constructor(subtype, timeoutMs) {
+    super("timeout", `control request '${subtype}' timed out after ${timeoutMs}ms`);
+    this.name = "WinterRpcTimeoutError";
+  }
+}
+
+// src/transport.ts
+var PLATFORM_PACKAGE = "@yanlinglabs/winter-agent-sdk-darwin-arm64";
+function resolveRuntimeExecutable(opts) {
+  if (opts.pathToClaudeCodeExecutable)
+    return opts.pathToClaudeCodeExecutable;
+  const require2 = createRequire(import.meta.url);
+  let pkgJsonPath;
+  try {
+    pkgJsonPath = require2.resolve(`${PLATFORM_PACKAGE}/package.json`);
+  } catch (err) {
+    throw new WinterSDKError(`runtime executable not found — no pathToClaudeCodeExecutable configured and the platform package ${PLATFORM_PACKAGE} is not installed for this platform (${err.message})`);
+  }
+  const pkg = require2(pkgJsonPath);
+  const binField = pkg.bin;
+  const relativeBin = typeof binField === "string" ? binField : binField?.winter;
+  if (!relativeBin) {
+    throw new WinterSDKError(`runtime executable not found — platform package ${PLATFORM_PACKAGE} has no "bin" entry configured yet`);
+  }
+  return join(dirname(pkgJsonPath), relativeBin);
+}
+function textChunks(stream) {
+  stream.setEncoding("utf8");
+  return async function* () {
+    try {
+      for await (const chunk of stream)
+        yield chunk;
+    } catch {
+      return;
+    }
+  }();
+}
+function defaultSpawn(opts) {
+  const child = spawn(opts.command, opts.args, {
+    cwd: opts.cwd,
+    env: opts.env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  let exitedSettled = false;
+  let resolveExited;
+  const exited = new Promise((resolve) => {
+    resolveExited = resolve;
+  });
+  child.on("close", (code, signal) => {
+    if (exitedSettled)
+      return;
+    exitedSettled = true;
+    resolveExited({ code, signal });
+  });
+  child.on("error", () => {
+    if (!exitedSettled) {
+      exitedSettled = true;
+      resolveExited({ code: null, signal: null });
+    }
+  });
+  child.stdin.on("error", () => {});
+  child.stdout.on("error", () => {});
+  child.stderr.on("error", () => {});
+  return {
+    stdin: {
+      write: (chunk) => {
+        child.stdin.write(chunk, "utf8");
+      },
+      end: () => {
+        child.stdin.end();
+      }
+    },
+    stdout: textChunks(child.stdout),
+    stderr: textChunks(child.stderr),
+    kill: (signal) => {
+      child.kill(signal);
+    },
+    exited,
+    get pid() {
+      return child.pid ?? null;
+    }
+  };
+}
+
+// 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/query.ts
+var DEFAULT_MAX_BUFFER_SIZE = 1024 * 1024;
+var KILL_GRACE_MS = 50;
+function hookIdFor(event, source, groupIndex, hookIndex) {
+  return `${event}:${source}:${groupIndex}:${hookIndex}`;
+}
+function toWireMcpServers(servers) {
+  if (!servers)
+    return;
+  const out = {};
+  for (const [name, cfg] of Object.entries(servers)) {
+    out[name] = cfg.type === "sdk" ? {
+      type: "sdk",
+      name: cfg.name,
+      ...cfg.timeout !== undefined ? { timeout: cfg.timeout } : {},
+      ...isWinterMcpServerInstance(cfg.instance) ? { tools: cfg.instance.listTools() } : {}
+    } : cfg;
+  }
+  return out;
+}
+function makeSdkMcpCallHandler(mcpServers) {
+  return async (payload) => {
+    const req = payload;
+    const cfg = req.server !== undefined ? mcpServers[req.server] : undefined;
+    if (!cfg || cfg.type !== "sdk") {
+      return { ok: false, error: { code: "unknown_sdk_server", message: `no in-process SDK server named '${String(req.server)}' is configured` } };
+    }
+    if (!isWinterMcpServerInstance(cfg.instance)) {
+      return {
+        ok: false,
+        error: {
+          code: "instance_not_callable",
+          message: `server '${req.server}'s instance does not implement listTools()/callTool() (WinterMcpServerInstance) -- it is wire-safe but not end-to-end callable`
+        }
+      };
+    }
+    try {
+      const result = await cfg.instance.callTool(req.tool ?? "", req.arguments ?? {});
+      return { ok: true, payload: result };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { ok: false, error: { code: "sdk_tool_threw", message } };
+    }
+  };
+}
+function makeElicitationHandler(onElicitation, abortController) {
+  return async (payload) => {
+    const req = payload;
+    const controller = new AbortController;
+    if (abortController?.signal.aborted)
+      controller.abort();
+    else
+      abortController?.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    let result;
+    try {
+      result = await onElicitation({
+        serverName: req.serverName ?? "",
+        message: req.message ?? "",
+        ...req.mode !== undefined ? { mode: req.mode } : {},
+        ...req.url !== undefined ? { url: req.url } : {},
+        ...req.elicitationId !== undefined ? { elicitationId: req.elicitationId } : {},
+        ...req.requestedSchema !== undefined ? { requestedSchema: req.requestedSchema } : {},
+        ...req.title !== undefined ? { title: req.title } : {},
+        ...req.displayName !== undefined ? { displayName: req.displayName } : {},
+        ...req.description !== undefined ? { description: req.description } : {}
+      }, { signal: controller.signal, requestId: randomUUID() });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`winter: onElicitation callback threw for server '${req.serverName}': ${message} -- declining deterministically`);
+      return { ok: true, payload: { action: "decline" } };
+    }
+    return { ok: true, payload: result ?? { action: "decline" } };
+  };
+}
+function buildRuntimeHooksConfig(hooks) {
+  if (!hooks)
+    return;
+  const out = {};
+  for (const [event, groups] of Object.entries(hooks)) {
+    if (!groups || groups.length === 0)
+      continue;
+    out[event] = groups.map((group) => {
+      const hookNames = group.hooks.map((hook) => hook.name || null);
+      return {
+        ...group.matcher !== undefined ? { matcher: group.matcher } : {},
+        hookCount: group.hooks.length,
+        ...group.timeout !== undefined ? { timeoutSec: group.timeout } : {},
+        source: "sdk",
+        ...hookNames.some((n) => n !== null) ? { hookNames } : {}
+      };
+    });
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+function buildHookInput(req, cwd) {
+  const payload = req.payload ?? {};
+  return {
+    session_id: req.sessionId,
+    transcript_path: "",
+    cwd,
+    ...req.agentID !== undefined ? { agent_id: req.agentID } : {},
+    hook_event_name: req.event,
+    ...req.toolName !== undefined ? { tool_name: req.toolName } : {},
+    ...req.input !== undefined ? { tool_input: req.input } : {},
+    ...req.toolUseID !== undefined ? { tool_use_id: req.toolUseID } : {},
+    ...payload
+  };
+}
+function makeHookHandler(hooks, cwd, abortController) {
+  const byId = new Map;
+  for (const [event, groups] of Object.entries(hooks)) {
+    (groups ?? []).forEach((group, groupIndex) => {
+      group.hooks.forEach((hook, hookIndex) => {
+        byId.set(hookIdFor(event, "sdk", groupIndex, hookIndex), hook);
+      });
+    });
+  }
+  return async (payload) => {
+    const req = payload;
+    const callback = byId.get(req.hookId);
+    if (!callback) {
+      return { ok: false, error: { code: "unknown_hook_id", message: `no SDK-callback hook registered for hookId '${req.hookId}'` } };
+    }
+    const controller = new AbortController;
+    if (abortController?.signal.aborted)
+      controller.abort();
+    else
+      abortController?.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    const input = buildHookInput(req, cwd);
+    let output;
+    try {
+      output = await callback(input, req.toolUseID, { signal: controller.signal });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`winter: hook callback threw for '${req.event}' (hookId '${req.hookId}'): ${message}`);
+      return { ok: false, error: { code: "hook_threw", message } };
+    }
+    return { ok: true, payload: output };
+  };
+}
+function isModelFamilyListing(payload) {
+  return typeof payload === "object" && payload !== null && Array.isArray(payload.families);
+}
+function query(args) {
+  const { prompt, options } = args;
+  if (options.canUseTool) {
+    const isBareOrBareEquivalent = (rule) => !rule.includes("(") || /\(\*\)$/.test(rule);
+    const hasBareAllowedTool = options.allowedTools?.some(isBareOrBareEquivalent) ?? false;
+    if (options.permissionMode === "bypassPermissions" || hasBareAllowedTool) {
+      const cause = options.permissionMode === "bypassPermissions" ? "permissionMode is 'bypassPermissions'" : "an allowedTools entry is bare (unscoped)";
+      console.error(`winter: WINTER_SDK_CAN_USE_TOOL_SHADOWED: canUseTool is configured but ${cause} — some or all tool calls will never reach it`);
+    }
+  }
+  if (options.sessionStore !== undefined && options.persistSession === false) {
+    const homeVar = envName({ envPrefix: options.brand?.envPrefix ?? WINTER_BRAND.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) {
+    throw new Error("enableFileCheckpointing is not yet supported with sessionStore (backup blobs are not mirrored, so rewindFiles() fails after a store-backed resume).");
+  }
+  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({
+    ...options.brand,
+    ...options.keychainService !== undefined ? { keychainService: options.keychainService } : {}
+  });
+  if (!brandResolution.ok)
+    throw new InvalidBrandError(brandResolution.reason);
+  const hostSetKeychainService = options.brand?.keychainService !== undefined || options.keychainService !== undefined;
+  const brand = {
+    ...brandResolution.brand,
+    keychainService: resolveKeychainServiceForProfile(brandResolution.brand, options.env, hostSetKeychainService)
+  };
+  const runtimeHooksConfig = buildRuntimeHooksConfig(options.hooks);
+  const wireMcpServers = toWireMcpServers(options.mcpServers);
+  const config = {
+    sessionId: options.sessionId ?? randomUUID(),
+    cwd: options.cwd ?? process.cwd(),
+    model: options.model ?? "sonnet",
+    permissionMode: options.permissionMode ?? "default",
+    ...options.maxTurns !== undefined ? { maxTurns: options.maxTurns } : {},
+    ...options.resume !== undefined ? { resume: options.resume } : {},
+    ...options.continue !== undefined ? { continue: options.continue } : {},
+    ...options.forkSession !== undefined ? { forkSession: options.forkSession } : {},
+    ...options.resumeSessionAt !== undefined ? { resumeSessionAt: options.resumeSessionAt } : {},
+    ...options.resumeDropsTurn !== undefined ? { resumeDropsTurn: options.resumeDropsTurn } : {},
+    ...options.persistSession !== undefined ? { persistSession: options.persistSession } : {},
+    ...options.allowedTools !== undefined ? { allowedTools: options.allowedTools } : {},
+    ...options.disallowedTools !== undefined ? { disallowedTools: options.disallowedTools } : {},
+    ...options.permissions !== undefined ? { permissions: options.permissions } : {},
+    ...options.settingSources !== undefined ? { settingSources: options.settingSources } : {},
+    ...options.managedSettings !== undefined ? { managedSettings: options.managedSettings } : {},
+    ...options.serverManagedSettings !== undefined ? { serverManagedSettings: options.serverManagedSettings } : {},
+    ...options.permissionPromptToolName !== undefined ? { permissionPromptToolName: options.permissionPromptToolName } : {},
+    ...options.additionalDirectories !== undefined ? { additionalDirectories: options.additionalDirectories } : {},
+    ...options.sandbox !== undefined ? { sandbox: options.sandbox } : {},
+    ...options.outputsDir !== undefined ? { outputsDir: options.outputsDir } : {},
+    ...options.capabilities !== undefined ? { capabilities: options.capabilities } : {},
+    ...options.toolSearchEnabled !== undefined ? { toolSearchEnabled: options.toolSearchEnabled } : {},
+    ...options.insideSubagent !== undefined ? { insideSubagent: options.insideSubagent } : {},
+    ...options.familyMetadata !== undefined ? { familyMetadata: options.familyMetadata } : {},
+    ...options.allowDangerouslySkipPermissions !== undefined ? { allowDangerouslySkipPermissions: options.allowDangerouslySkipPermissions } : {},
+    ...runtimeHooksConfig !== undefined ? { hooks: runtimeHooksConfig } : {},
+    ...options.includeHookEvents !== undefined ? { includeHookEvents: options.includeHookEvents } : {},
+    ...wireMcpServers !== undefined ? { mcpServers: wireMcpServers } : {},
+    ...options.strictMcpConfig !== undefined ? { strictMcpConfig: options.strictMcpConfig } : {},
+    ...options.toolAliases !== undefined ? { toolAliases: options.toolAliases } : {},
+    ...options.agents !== undefined ? { agents: options.agents } : {},
+    ...options.forwardSubagentText !== undefined ? { forwardSubagentText: options.forwardSubagentText } : {},
+    ...options.systemPrompt !== undefined ? { systemPrompt: options.systemPrompt } : {},
+    ...options.plugins !== undefined ? { plugins: options.plugins } : {},
+    ...options.skills !== undefined ? { skills: options.skills } : {},
+    ...options.outputFormat !== undefined ? { outputFormat: options.outputFormat } : {},
+    ...options.enableFileCheckpointing !== undefined ? { enableFileCheckpointing: options.enableFileCheckpointing } : {},
+    ...options.contextWindowTokens !== undefined ? { contextWindowTokens: options.contextWindowTokens } : {},
+    ...options.compactionThreshold !== undefined ? { compactionThreshold: options.compactionThreshold } : {},
+    ...options.trustedWorkspace !== undefined ? { trustedWorkspace: options.trustedWorkspace } : {},
+    ...options.plansDirectory !== undefined ? { plansDirectory: options.plansDirectory } : {},
+    ...options.outputStyle !== undefined ? { outputStyle: options.outputStyle } : {},
+    ...options.provider !== undefined ? { provider: options.provider } : {},
+    ...options.fallbackModel !== undefined ? { fallbackModel: options.fallbackModel } : {},
+    ...options.thinking !== undefined ? { thinking: options.thinking } : {},
+    ...options.effort !== undefined ? { effort: options.effort } : {},
+    ...options.maxThinkingTokens !== undefined ? { maxThinkingTokens: options.maxThinkingTokens } : {},
+    ...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 } : {},
+    ...options.autoClassifier !== undefined ? { autoClassifier: options.autoClassifier } : {},
+    ...options.advisor !== undefined ? { advisor: options.advisor } : {},
+    brand
+  };
+  const command = options.spawnClaudeCodeProcess ? options.pathToClaudeCodeExecutable ?? "winter" : resolveRuntimeExecutable(options);
+  const spawnOptions = {
+    command,
+    args: ["--run", "--config-json", JSON.stringify(config)],
+    cwd: config.cwd,
+    env: options.env ?? process.env,
+    ...options.abortController ? { signal: options.abortController.signal } : {}
+  };
+  const proc = (options.spawnClaudeCodeProcess ?? defaultSpawn)(spawnOptions);
+  const maxBufferSize = options.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE;
+  const pendingHostRequests = new Map;
+  let generatorTerminated = false;
+  function sendControlRequest(subtype, payload) {
+    if (generatorTerminated) {
+      return Promise.reject(new WinterRpcError("connection_closed", `query() has already completed: cannot issue a '${subtype}' control request`));
+    }
+    const requestId = randomUUID();
+    return new Promise((resolve, reject) => {
+      pendingHostRequests.set(requestId, { resolve, reject });
+      proc.stdin.write(encodeFrame({ type: "control_request", requestId, subtype, payload }));
+    });
+  }
+  const respondedOutOfBand = new Set;
+  function writeControlResponse(frame) {
+    if (respondedOutOfBand.delete(frame.requestId))
+      return;
+    proc.stdin.write(encodeFrame(frame));
+  }
+  const controlRequestHandlers = new Map;
+  async function handleIncomingControlRequest(cf) {
+    try {
+      const handler = controlRequestHandlers.get(cf.subtype);
+      if (!handler) {
+        writeControlResponse({
+          type: "control_response",
+          requestId: cf.requestId,
+          ok: false,
+          error: { code: "unhandled_subtype", message: `no handler registered for control subtype '${cf.subtype}'` }
+        });
+        return;
+      }
+      try {
+        const result = await handler(cf.payload);
+        if (result.ok) {
+          writeControlResponse({
+            type: "control_response",
+            requestId: cf.requestId,
+            ok: true,
+            ...result.payload !== undefined ? { payload: result.payload } : {}
+          });
+        } else {
+          writeControlResponse({ type: "control_response", requestId: cf.requestId, ok: false, error: result.error });
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        writeControlResponse({ type: "control_response", requestId: cf.requestId, ok: false, error: { code: "handler_threw", message } });
+      }
+    } catch {}
+  }
+  function makePermissionHandler(canUseTool) {
+    return async (payload) => {
+      const req = payload;
+      const controller = new AbortController;
+      if (options.abortController?.signal.aborted)
+        controller.abort();
+      else
+        options.abortController?.signal.addEventListener("abort", () => controller.abort(), { once: true });
+      let result;
+      try {
+        result = await canUseTool(req.toolName, req.input, {
+          signal: controller.signal,
+          ...req.suggestions !== undefined ? { suggestions: req.suggestions } : {},
+          ...req.blockedPath !== undefined ? { blockedPath: req.blockedPath } : {},
+          ...req.decisionReason !== undefined ? { decisionReason: req.decisionReason } : {},
+          ...req.title !== undefined ? { title: req.title } : {},
+          ...req.displayName !== undefined ? { displayName: req.displayName } : {},
+          ...req.description !== undefined ? { description: req.description } : {},
+          toolUseID: req.toolUseID,
+          ...req.agentID !== undefined ? { agentID: req.agentID } : {},
+          requestId: req.requestId,
+          ...req.matchedAskRule !== undefined ? { matchedAskRule: req.matchedAskRule } : {}
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`winter: canUseTool callback threw for '${req.toolName}': ${message} — failing closed (deny)`);
+        const deny = { behavior: "deny", message: `canUseTool callback threw: ${message}` };
+        return { ok: true, payload: deny };
+      }
+      if (result === null) {
+        if (respondedOutOfBand.has(req.requestId)) {
+          return { ok: true };
+        }
+        console.error(`winter: canUseTool callback for '${req.toolName}' returned null with no prior out-of-band response — failing closed (deny)`);
+        const deny = {
+          behavior: "deny",
+          message: "canUseTool callback returned null with no prior out-of-band response (accidental null fails closed, WS-07 §7.2)"
+        };
+        return { ok: true, payload: deny };
+      }
+      return { ok: true, payload: result };
+    };
+  }
+  if (options.canUseTool) {
+    controlRequestHandlers.set("permission", makePermissionHandler(options.canUseTool));
+  }
+  if (options.hooks && Object.keys(options.hooks).length > 0) {
+    controlRequestHandlers.set("hook", makeHookHandler(options.hooks, config.cwd, options.abortController));
+  }
+  if (options.mcpServers && Object.values(options.mcpServers).some((cfg) => cfg.type === "sdk")) {
+    controlRequestHandlers.set("sdk_mcp_call", makeSdkMcpCallHandler(options.mcpServers));
+  }
+  if (options.onElicitation) {
+    controlRequestHandlers.set("mcp_elicitation", makeElicitationHandler(options.onElicitation, options.abortController));
+  }
+  if (proc.stderr) {
+    const stderrIterable = proc.stderr;
+    (async () => {
+      try {
+        for await (const chunk of stderrIterable)
+          options.stderr?.(chunk);
+      } catch {}
+    })();
+  }
+  async function* iterate() {
+    let aborted = false;
+    let killTimer;
+    const onAbort = () => {
+      if (aborted)
+        return;
+      aborted = true;
+      proc.kill();
+      killTimer = setTimeout(() => proc.kill("SIGKILL"), KILL_GRACE_MS);
+      killTimer.unref?.();
+    };
+    options.abortController?.signal.addEventListener("abort", onAbort);
+    try {
+      if (options.abortController?.signal.aborted)
+        onAbort();
+      (async () => {
+        try {
+          if (typeof prompt === "string") {
+            proc.stdin.write(encodeFrame({ type: "user", text: prompt }));
+          } else {
+            for await (const text of prompt) {
+              proc.stdin.write(encodeFrame({ type: "user", text }));
+            }
+          }
+          sendControlRequest("end_input", undefined).catch(() => {});
+        } catch {}
+      })();
+      let sawInit = false;
+      let sawTerminal = false;
+      let terminalError = null;
+      let carry = "";
+      const isStreamingInput = typeof prompt !== "string";
+      readLoop:
+        for await (const chunk of proc.stdout) {
+          let frames;
+          try {
+            const split = splitFrames(chunk, carry);
+            frames = split.frames;
+            carry = split.carry;
+          } catch (e) {
+            throw new ProtocolDecodeError(e instanceof ProtocolError ? e.message : String(e));
+          }
+          for (const frame of frames) {
+            if (!sawInit) {
+              if (frame.type !== "init") {
+                throw new ProtocolDecodeError(`protocol violation: expected 'init' as the first frame, got '${frame.type}'`);
+              }
+              const init = frame;
+              const runtimeMajor = init.protocolVersion.split(".")[0];
+              const sdkMajor = PROTOCOL_VERSION.split(".")[0];
+              if (runtimeMajor !== sdkMajor) {
+                throw new CLIConnectionError(`protocol version mismatch: runtime speaks ${init.protocolVersion}, sdk expects ${PROTOCOL_VERSION}`);
+              }
+              sawInit = true;
+              continue;
+            }
+            if (frame.type === "control_response") {
+              const cf = frame;
+              const pendingReq = pendingHostRequests.get(cf.requestId);
+              if (pendingReq) {
+                pendingHostRequests.delete(cf.requestId);
+                if (cf.ok)
+                  pendingReq.resolve(cf.payload);
+                else
+                  pendingReq.reject(new WinterRpcError(cf.error?.code ?? "unknown_error", cf.error?.message ?? "control request failed"));
+              }
+              continue;
+            }
+            if (frame.type === "control_request") {
+              handleIncomingControlRequest(frame);
+              continue;
+            }
+            if (frame.type !== "data")
+              continue;
+            const message = frame.message;
+            yield message;
+            if (message.type === "result") {
+              sawTerminal = true;
+              if (message.is_error)
+                terminalError = message;
+              if (!isStreamingInput)
+                break readLoop;
+            }
+          }
+          if (carry.length > maxBufferSize) {
+            throw new ProtocolDecodeError(`protocol line exceeds maxBufferSize (${maxBufferSize} bytes)`);
+          }
+        }
+      if (terminalError)
+        throw new ResultError(terminalError);
+      if (sawTerminal)
+        return;
+      if (aborted)
+        throw new AbortError("query aborted: runtime process killed");
+      if (!sawInit)
+        throw new CLIConnectionError("runtime exited before init");
+      const exitInfo = await proc.exited;
+      throw new ProcessError("unexpected process death: runtime exited without a terminal result", exitInfo.code, exitInfo.signal);
+    } finally {
+      generatorTerminated = true;
+      options.abortController?.signal.removeEventListener("abort", onAbort);
+      if (killTimer)
+        clearTimeout(killTimer);
+      try {
+        proc.stdin.end();
+      } catch {}
+      if (pendingHostRequests.size > 0) {
+        const err = new WinterRpcError("connection_closed", "runtime connection closed before this control request was acknowledged");
+        for (const pendingReq of pendingHostRequests.values())
+          pendingReq.reject(err);
+        pendingHostRequests.clear();
+      }
+    }
+  }
+  const gen = iterate();
+  gen.interrupt = async () => {
+    await sendControlRequest("interrupt", { scope: "turn" });
+  };
+  gen.setModel = async (model) => {
+    await sendControlRequest("set_model", model !== undefined ? { model } : {});
+  };
+  gen.supportedModels = async () => {
+    const payload = await sendControlRequest("list_models", undefined);
+    return Array.isArray(payload) ? payload : [];
+  };
+  gen.listModelFamilies = async () => {
+    const payload = await sendControlRequest("list_model_families", undefined);
+    return isModelFamilyListing(payload) ? payload : { active: undefined, families: [] };
+  };
+  gen.accountInfo = async () => {
+    const payload = await sendControlRequest("account_info", undefined);
+    return typeof payload === "object" && payload !== null && !Array.isArray(payload) ? payload : {};
+  };
+  gen.setPermissionMode = async (mode) => {
+    await sendControlRequest("set_permission_mode", mode);
+  };
+  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") {
+      return { canRewind: false, error: "the runtime returned no rewind result" };
+    }
+    return payload;
+  };
+  gen.__internal = {
+    registerControlRequestHandler(subtype, handler) {
+      controlRequestHandlers.set(subtype, handler);
+    },
+    respondPermission(requestId, result) {
+      respondedOutOfBand.add(requestId);
+      try {
+        proc.stdin.write(encodeFrame({ type: "control_response", requestId, ok: true, payload: result }));
+      } catch {}
+    }
+  };
+  return gen;
+}
+// src/paths/project-key.ts
+var MAX_UNSUFFIXED_LENGTH = 200;
+function sanitize(absPath) {
+  return absPath.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function rollingHash32(raw) {
+  let hash = 0;
+  for (let i = 0;i < raw.length; i++) {
+    hash = (hash << 5) - hash + raw.charCodeAt(i) | 0;
+  }
+  return hash;
+}
+function overflowSuffix(rawAbsPath) {
+  return Math.abs(rollingHash32(rawAbsPath)).toString(36);
+}
+function transcriptProjectKey(absPath) {
+  const sanitized = sanitize(absPath);
+  if (sanitized.length <= MAX_UNSUFFIXED_LENGTH)
+    return sanitized;
+  return `${sanitized.slice(0, MAX_UNSUFFIXED_LENGTH)}-${overflowSuffix(absPath)}`;
+}
+// src/paths/keys.ts
+import { realpathSync } from "node:fs";
+import { resolve as resolvePath, dirname as dirname2, isAbsolute } from "node:path";
+import { execFileSync } from "node:child_process";
+function platformNormalize(p) {
+  return process.platform === "darwin" ? p.normalize("NFC") : p;
+}
+function resolveCanonical(raw) {
+  const resolved = resolvePath(raw);
+  try {
+    return platformNormalize(realpathSync(resolved));
+  } catch {
+    return platformNormalize(resolved);
+  }
+}
+function gitCommonRoot(resolvedCwd) {
+  try {
+    const raw = execFileSync("git", ["-C", resolvedCwd, "rev-parse", "--git-common-dir"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const commonDir = isAbsolute(raw) ? raw : resolvePath(resolvedCwd, raw);
+    return platformNormalize(dirname2(realpathSync(commonDir)));
+  } catch {
+    return null;
+  }
+}
+function compatibilityKeys(cwd) {
+  const resolvedCwd = resolveCanonical(cwd);
+  const cwdKey = transcriptProjectKey(resolvedCwd);
+  const commonRoot = gitCommonRoot(resolvedCwd);
+  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";
+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 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);
+  const carry = store;
+  try {
+    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 };
+      for (const field of IDENTITY_FIELDS) {
+        const value = summary[field];
+        if (typeof value === "string")
+          identity[field] = value;
+      }
+      await store.append(destKey, [identity]);
+    }
+  } catch {}
+  return { sessionId: newSessionId };
+}
+// src/sessions.ts
+function resolveHome(winterHome, brand) {
+  if (winterHome !== undefined)
+    return winterHome;
+  if (brand === undefined)
+    return resolveWinterHome();
+  const resolved = resolveBrand(brand);
+  if (!resolved.ok)
+    throw new TypeError(`sessions: invalid brand profile -- ${resolved.reason}`);
+  return resolveWinterHome(undefined, resolved.brand);
+}
+function openStore(opts) {
+  return new WinterCompatibilitySessionStore({ winterHome: resolveHome(opts?.winterHome, opts?.brand) });
+}
+async function findInProject(store, projectKey, sessionId) {
+  const sessions = await store.listSessions(projectKey);
+  return sessions.find((s) => s.sessionId === sessionId);
+}
+async function resolveSession(store, sessionId, directory) {
+  if (directory !== undefined) {
+    const projectKey = compatibilityKeys(directory).transcriptProjectKey;
+    const found = await findInProject(store, projectKey, sessionId);
+    if (found === undefined) {
+      throw new SessionNotFoundError("not_found", `session not found: ${sessionId} (in directory-scoped project ${projectKey})`);
+    }
+    return { projectKey, mtime: found.mtime };
+  }
+  const allProjectKeys = await store.listProjectKeys();
+  const matches = [];
+  for (const projectKey of allProjectKeys) {
+    const found = await findInProject(store, projectKey, sessionId);
+    if (found !== undefined)
+      matches.push({ projectKey, mtime: found.mtime });
+  }
+  if (matches.length === 0) {
+    throw new SessionNotFoundError("not_found", `session not found in any project: ${sessionId}`);
+  }
+  if (matches.length > 1) {
+    throw new SessionNotFoundError("ambiguous", `session ${sessionId} found in ${matches.length} projects (${matches.map((m) => m.projectKey).join(", ")}); refusing to pick arbitrarily`);
+  }
+  return matches[0];
+}
+async function listSessions(opts) {
+  const store = openStore(opts);
+  const projectKeys = opts?.directory !== undefined ? [compatibilityKeys(opts.directory).transcriptProjectKey] : await store.listProjectKeys();
+  const result = [];
+  for (const projectKey of projectKeys) {
+    const [sessions, summaries] = await Promise.all([store.listSessions(projectKey), store.listSessionSummaries(projectKey)]);
+    const summaryById = new Map(summaries.map((s) => [s.sessionId, s]));
+    for (const s of sessions) {
+      const summary = summaryById.get(s.sessionId);
+      result.push({
+        sessionId: s.sessionId,
+        projectKey,
+        mtime: s.mtime,
+        ...summary?.name !== undefined ? { name: summary.name } : {},
+        ...summary?.tags !== undefined ? { tags: summary.tags } : {}
+      });
+    }
+  }
+  return result;
+}
+async function getSessionInfo(sessionId, opts) {
+  const store = openStore(opts);
+  const { projectKey, mtime } = await resolveSession(store, sessionId, opts?.directory);
+  const summaries = await store.listSessionSummaries(projectKey);
+  const summary = summaries.find((s) => s.sessionId === sessionId);
+  const entryCount = summary?.entryCount ?? (await store.load({ projectKey, sessionId }))?.length ?? 0;
+  return {
+    sessionId,
+    projectKey,
+    mtime,
+    entryCount,
+    ...summary?.name !== undefined ? { name: summary.name } : {},
+    ...summary?.tags !== undefined ? { tags: summary.tags } : {}
+  };
+}
+async function getSessionMessages(sessionId, opts) {
+  const store = openStore(opts);
+  const { projectKey } = await resolveSession(store, sessionId, opts?.directory);
+  const entries = await store.load({ projectKey, sessionId });
+  return entries ?? [];
+}
+async function renameSession(sessionId, name, opts) {
+  const store = openStore(opts);
+  const { projectKey } = await resolveSession(store, sessionId, opts?.directory);
+  await store.mergeSessionMetadata({ projectKey, sessionId }, { name });
+}
+async function tagSession(sessionId, tags, opts) {
+  const store = openStore(opts);
+  const { projectKey } = await resolveSession(store, sessionId, opts?.directory);
+  await store.mergeSessionMetadata({ projectKey, sessionId }, { tags });
+}
+async function deleteSession(sessionId, opts) {
+  const store = openStore(opts);
+  const { projectKey } = await resolveSession(store, sessionId, opts?.directory);
+  await store.delete({ projectKey, sessionId });
+}
+async function forkSession(sessionId, opts) {
+  const store = openStore(opts);
+  const { projectKey } = await resolveSession(store, sessionId, opts?.directory);
+  return forkSessionByKey(store, { projectKey, sessionId });
+}
+var SUBAGENT_SUBPATH_PREFIX = "subagents/";
+async function listSubagents(sessionId, opts) {
+  const store = openStore(opts);
+  const { projectKey } = await resolveSession(store, sessionId, opts?.directory);
+  const subkeys = await store.listSubkeys({ projectKey, sessionId });
+  const agents = [];
+  for (const subkey of subkeys) {
+    if (subkey.startsWith(SUBAGENT_SUBPATH_PREFIX)) {
+      agents.push({ agentId: subkey.slice(SUBAGENT_SUBPATH_PREFIX.length) });
+    }
+  }
+  return agents;
+}
+async function getSubagentMessages(sessionId, agentId, opts) {
+  const store = openStore(opts);
+  const { projectKey } = await resolveSession(store, sessionId, opts?.directory);
+  const entries = await store.load({ projectKey, sessionId, subpath: `${SUBAGENT_SUBPATH_PREFIX}${agentId}` });
+  if (entries === null) {
+    throw new SessionNotFoundError("not_found", `subagent not found: ${agentId} (session ${sessionId})`);
+  }
+  return entries;
+}
+// src/settings/sources.ts
+import { readFile } from "node:fs/promises";
+import { join as join4 } from "node:path";
+function settingsPathFor(source, opts) {
+  const brand = opts.brand ?? WINTER_BRAND;
+  switch (source) {
+    case "user":
+      return join4(opts.winterHome ?? resolveWinterHome(opts.env, brand), "settings.json");
+    case "project":
+      return join4(opts.cwd, brand.projectDirName, "settings.json");
+    case "local":
+      return join4(opts.cwd, brand.projectDirName, "settings.local.json");
+  }
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+async function loadSettingsFile(path) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT" || code === "ENOTDIR")
+      return { present: false, loaded: false, values: {} };
+    return { present: true, loaded: false, error: `unreadable: ${err.message}`, values: {} };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return { present: true, loaded: false, error: `malformed JSON: ${err.message}`, values: {} };
+  }
+  if (!isPlainObject(parsed)) {
+    return { present: true, loaded: false, error: `expected a JSON object at the top level, got ${Array.isArray(parsed) ? "an array" : typeof parsed}`, values: {} };
+  }
+  return { present: true, loaded: true, values: parsed };
+}
+
+// src/settings/types.ts
+var SETTING_SOURCES = ["user", "project", "local"];
+function providerSettingsFrom(settings) {
+  const raw = settings?.["providers"];
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+    return {};
+  const out = {};
+  for (const [id, value] of Object.entries(raw)) {
+    if (id.length === 0)
+      continue;
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+      continue;
+    const enabled = value.enabled;
+    out[id] = { enabled: enabled === false ? false : true };
+  }
+  return out;
+}
+var OVERLAY_NEVER_KEYS = ["autoMemoryDirectory", "autoMode", "outputStyle"];
+var ESCALATING_PERMISSION_MODES = ["bypassPermissions", "auto", "acceptEdits"];
+var PROJECT_PERMISSIVE_KEYS = ["allow", "additionalDirectories"];
+
+// src/settings/resolve.ts
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepMergeInto(target, overlay) {
+  for (const [key, value] of Object.entries(overlay)) {
+    if (value === undefined)
+      continue;
+    const existing = target[key];
+    if (isPlainObject2(existing) && isPlainObject2(value)) {
+      const merged = { ...existing };
+      deepMergeInto(merged, value);
+      target[key] = merged;
+      continue;
+    }
+    target[key] = value;
+  }
+}
+var MAX_PLANS_DIRECTORY_LENGTH = 200;
+function validateProjectPlansDirectory(value) {
+  if (typeof value !== "string")
+    return { ok: false, reason: `"plansDirectory" must be a string, got ${typeof value}` };
+  if (value.length === 0)
+    return { ok: false, reason: `"plansDirectory" must not be empty` };
+  if (value.length > MAX_PLANS_DIRECTORY_LENGTH)
+    return { ok: false, reason: `"plansDirectory" exceeds ${MAX_PLANS_DIRECTORY_LENGTH} characters` };
+  if (/[\u0000-\u001f\u007f]/.test(value))
+    return { ok: false, reason: `"plansDirectory" contains control characters, which cannot appear in a path` };
+  if (value.startsWith("/") || value.startsWith("~"))
+    return { ok: false, reason: `"plansDirectory" from the project tier must be RELATIVE to the project root` };
+  if (value.split("/").includes(".."))
+    return { ok: false, reason: `"plansDirectory" from the project tier must not traverse upward` };
+  return { ok: true };
+}
+function describeMalformedPermissionArrays(values) {
+  const permissions = values["permissions"];
+  if (!isPlainObject2(permissions)) {
+    return permissions === undefined ? undefined : `"permissions" must be an object, got ${Array.isArray(permissions) ? "an array" : typeof permissions}`;
+  }
+  const problems = [];
+  for (const key of ["allow", "ask", "deny", "additionalDirectories"]) {
+    const value = permissions[key];
+    if (value === undefined)
+      continue;
+    if (!Array.isArray(value)) {
+      problems.push(`"permissions.${key}" must be an array of strings, got ${typeof value}`);
+      continue;
+    }
+    const bad = value.filter((item) => typeof item !== "string").length;
+    if (bad > 0)
+      problems.push(`"permissions.${key}" has ${bad} non-string entr${bad === 1 ? "y" : "ies"}, which are ignored`);
+  }
+  return problems.length > 0 ? problems.join("; ") : undefined;
+}
+function describeOverlayNeverKeys(values) {
+  const present = OVERLAY_NEVER_KEYS.filter((key) => values[key] !== undefined);
+  if (present.length === 0)
+    return;
+  return `${present.map((k) => `"${k}"`).join(", ")} ${present.length === 1 ? "is" : "are"} ignored from the project tier (a repository may not set ${present.length === 1 ? "it" : "them"}); move ${present.length === 1 ? "it" : "them"} to your user settings`;
+}
+function withoutOverlayNeverKeys(values) {
+  const out = { ...values };
+  for (const key of OVERLAY_NEVER_KEYS)
+    delete out[key];
+  if ("plansDirectory" in out && !validateProjectPlansDirectory(out["plansDirectory"]).ok)
+    delete out["plansDirectory"];
+  return out;
+}
+var MODEL_SLOT_KEYS = ["modelSlots", "preferredProviders", "advisor"];
+function describeUntrustedModelSlotKeys(values) {
+  const present = MODEL_SLOT_KEYS.filter((key) => values[key] !== undefined);
+  if (present.length === 0)
+    return;
+  return `${present.map((k) => `"${k}"`).join(", ")} ${present.length === 1 ? "is" : "are"} ignored from the project tier (untrusted workspace, WS-13c R13c-7 / D30): a repository may not choose which models the agent uses, nor which model the advisor sends this session's conversation to; declare the workspace trusted, or set ${present.length === 1 ? "it" : "them"} in your user settings`;
+}
+function withoutUntrustedModelSlotKeys(values) {
+  const out = { ...values };
+  for (const key of MODEL_SLOT_KEYS)
+    delete out[key];
+  return out;
+}
+function projectTierContribution(values, trustedWorkspace) {
+  const withoutNever = withoutOverlayNeverKeys(values);
+  return trustedWorkspace ? withoutNever : withoutUntrustedModelSlotKeys(withoutNever);
+}
+var DERIVED_ONLY_KEYS = ["modelSlotsIgnored"];
+function withoutDerivedOnlyKeys(values) {
+  const out = { ...values };
+  for (const key of DERIVED_ONLY_KEYS)
+    delete out[key];
+  return out;
+}
+function tierContribution(values, isProject, trustedWorkspace) {
+  const projectFiltered = isProject ? projectTierContribution(values, trustedWorkspace) : values;
+  return withoutDerivedOnlyKeys(projectFiltered);
+}
+var PERMISSION_RULE_ARRAY_KEYS = ["allow", "ask", "deny", "additionalDirectories"];
+function stringArrayOrUndefined(v) {
+  if (!Array.isArray(v))
+    return;
+  const strings = v.filter((item) => typeof item === "string");
+  return strings.length > 0 ? strings : undefined;
+}
+function unionRuleArray(tiersLowestFirst, key) {
+  const seen = new Set;
+  const out = [];
+  for (const tier of tiersLowestFirst) {
+    const permissions = tier.values["permissions"];
+    if (!isPlainObject2(permissions))
+      continue;
+    for (const rule of stringArrayOrUndefined(permissions[key]) ?? []) {
+      if (seen.has(rule))
+        continue;
+      seen.add(rule);
+      out.push(rule);
+    }
+  }
+  return out.length > 0 ? out : undefined;
+}
+function restrictProviderEnables(effective, tiersLowestFirst) {
+  const disabled = new Set;
+  for (const tier of tiersLowestFirst) {
+    const block = tier.values["providers"];
+    if (!isPlainObject2(block))
+      continue;
+    for (const [id, value] of Object.entries(block)) {
+      if (isPlainObject2(value) && value.enabled === false)
+        disabled.add(id);
+    }
+  }
+  if (disabled.size === 0)
+    return;
+  const merged = effective["providers"];
+  const providers = isPlainObject2(merged) ? { ...merged } : {};
+  for (const id of disabled) {
+    const entry = providers[id];
+    providers[id] = { ...isPlainObject2(entry) ? entry : {}, enabled: false };
+  }
+  effective["providers"] = providers;
+}
+function unionPermissionRuleArrays(effective, tiersLowestFirst) {
+  const merged = effective["permissions"];
+  const permissions = isPlainObject2(merged) ? { ...merged } : {};
+  let any = isPlainObject2(merged);
+  for (const key of PERMISSION_RULE_ARRAY_KEYS) {
+    const unioned = unionRuleArray(tiersLowestFirst, key);
+    if (unioned === undefined)
+      delete permissions[key];
+    else {
+      permissions[key] = unioned;
+      any = true;
+    }
+  }
+  if (any)
+    effective["permissions"] = permissions;
+}
+var SOURCE_ORDER_LOWEST_FIRST = ["user", "project", "local"];
+async function resolveSettingsDetailed(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const selected = opts.settingSources ?? SETTING_SOURCES;
+  const pathOpts = {
+    cwd,
+    ...opts.winterHome !== undefined ? { winterHome: opts.winterHome } : {},
+    ...opts.env !== undefined ? { env: opts.env } : {},
+    ...opts.brand !== undefined ? { brand: opts.brand } : {}
+  };
+  const lowestFirst = [];
+  for (const source of SOURCE_ORDER_LOWEST_FIRST) {
+    if (!selected.includes(source))
+      continue;
+    const path = settingsPathFor(source, pathOpts);
+    const file = await loadSettingsFile(path);
+    if (!file.present)
+      continue;
+    const valueError = describeMalformedPermissionArrays(file.values);
+    const plansCheck = source === "project" && file.values["plansDirectory"] !== undefined ? validateProjectPlansDirectory(file.values["plansDirectory"]) : { ok: true };
+    const plansError = plansCheck.ok ? undefined : plansCheck.reason;
+    const neverKeyError = source === "project" ? describeOverlayNeverKeys(file.values) : undefined;
+    const untrustedModelSlotsError = source === "project" && opts.trustedWorkspace !== true ? describeUntrustedModelSlotKeys(file.values) : undefined;
+    const mergedError = [file.error, valueError, plansError, neverKeyError, untrustedModelSlotsError].filter((e) => e !== undefined).join("; ");
+    lowestFirst.push({
+      source,
+      path,
+      settings: file.values,
+      values: file.values,
+      loaded: file.loaded,
+      ...mergedError.length > 0 ? { error: mergedError } : {}
+    });
+  }
+  if (opts.inline !== undefined) {
+    lowestFirst.push({ source: "flag", settings: opts.inline, values: opts.inline, loaded: true });
+  }
+  if (opts.managedSettings !== undefined) {
+    lowestFirst.push({ source: "managed", policyOrigin: "file", settings: opts.managedSettings, values: opts.managedSettings, loaded: true });
+  }
+  if (opts.serverManagedSettings !== undefined) {
+    lowestFirst.push({ source: "managed", policyOrigin: "remote", settings: opts.serverManagedSettings, values: opts.serverManagedSettings, loaded: true });
+  }
+  const trustedWorkspace = opts.trustedWorkspace === true;
+  const effective = {};
+  const provenance = {};
+  for (const entry of lowestFirst) {
+    const contribution = tierContribution(entry.values, entry.source === "project", trustedWorkspace);
+    deepMergeInto(effective, contribution);
+    for (const key of Object.keys(contribution)) {
+      if (contribution[key] === undefined)
+        continue;
+      provenance[key] = {
+        source: entry.source,
+        ...entry.path !== undefined ? { path: entry.path } : {},
+        ...entry.policyOrigin !== undefined ? { policyOrigin: entry.policyOrigin } : {}
+      };
+    }
+  }
+  const overlayFilteredTiers = lowestFirst.map((entry) => ({ values: tierContribution(entry.values, entry.source === "project", trustedWorkspace) }));
+  unionPermissionRuleArrays(effective, overlayFilteredTiers);
+  restrictProviderEnables(effective, overlayFilteredTiers);
+  if (!trustedWorkspace) {
+    const projectIndex = lowestFirst.findIndex((e) => e.source === "project");
+    if (projectIndex !== -1) {
+      const projectValues = lowestFirst[projectIndex].values;
+      const projectHadEither = MODEL_SLOT_KEYS.some((key) => projectValues[key] !== undefined);
+      if (projectHadEither) {
+        const higherProvidedModelSlots = lowestFirst.slice(projectIndex + 1).some((e) => e.values["modelSlots"] !== undefined);
+        if (!higherProvidedModelSlots)
+          effective["modelSlotsIgnored"] = "untrusted-project";
+      }
+    }
+  }
+  const perSource = [...lowestFirst].reverse();
+  return {
+    effective,
+    provenance,
+    sources: perSource.map((e) => ({
+      source: e.source,
+      settings: e.settings,
+      ...e.path !== undefined ? { path: e.path } : {},
+      ...e.policyOrigin !== undefined ? { policyOrigin: e.policyOrigin } : {}
+    })),
+    perSource
+  };
+}
+async function resolveSettings(opts) {
+  const { effective, provenance, sources } = await resolveSettingsDetailed(opts ?? {});
+  return { effective, provenance, sources };
+}
+function winningSourceFor(resolved, path) {
+  for (const entry of resolved.sources) {
+    let cursor = entry.settings;
+    let found = true;
+    for (const segment of path) {
+      if (!isPlainObject2(cursor) || !(segment in cursor)) {
+        found = false;
+        break;
+      }
+      cursor = cursor[segment];
+    }
+    if (found && cursor !== undefined)
+      return entry;
+  }
+  return;
+}
+function filterEscalatingDefaultMode(resolved) {
+  const permissions = resolved.effective["permissions"];
+  if (!isPlainObject2(permissions))
+    return { ...resolved.effective };
+  const defaultMode = permissions["defaultMode"];
+  if (typeof defaultMode !== "string" || !ESCALATING_PERMISSION_MODES.includes(defaultMode))
+    return { ...resolved.effective };
+  if (winningSourceFor(resolved, ["permissions", "defaultMode"])?.source !== "project")
+    return { ...resolved.effective };
+  const nextPermissions = { ...permissions };
+  delete nextPermissions["defaultMode"];
+  return { ...resolved.effective, permissions: nextPermissions };
+}
+function applyWorkspaceTrust(resolved, opts = {}) {
+  const afterModeFilter = filterEscalatingDefaultMode(resolved);
+  if (opts.trustedWorkspace === true)
+    return afterModeFilter;
+  const permissions = afterModeFilter["permissions"];
+  if (!isPlainObject2(permissions))
+    return afterModeFilter;
+  const nonProject = resolved.sources.filter((s) => s.source !== "project").map((s) => ({ values: s.settings }));
+  const nonProjectLowestFirst = [...nonProject].reverse();
+  const nextPermissions = { ...permissions };
+  let changed = false;
+  for (const key of PROJECT_PERMISSIVE_KEYS) {
+    if (!(key in nextPermissions))
+      continue;
+    const withoutProject = unionRuleArray(nonProjectLowestFirst, key);
+    const before = nextPermissions[key];
+    if (withoutProject === undefined)
+      delete nextPermissions[key];
+    else
+      nextPermissions[key] = withoutProject;
+    if (JSON.stringify(before) !== JSON.stringify(withoutProject))
+      changed = true;
+  }
+  return changed ? { ...afterModeFilter, permissions: nextPermissions } : afterModeFilter;
+}
+// src/settings/model-slots.ts
+import { CLAUDE_RESERVED_SLOT_NAMES, CURRENCY_RE, SLOT_NAME_RE } from "@yanlinglabs/winter-provider-catalog/families";
+var MAX_SLOTS = 4;
+var MAX_DESCRIPTION_LENGTH = 200;
+var EXTRA_CURRENCY_RE = /(?:[¥¢]\s?\d)|(?:\d\s?¢)|(?:\d+(?:\.\d+)?\s?(?:eur|euros?|cents?)\b)/i;
+function hasCurrencyAmount(text) {
+  return CURRENCY_RE.test(text) || EXTRA_CURRENCY_RE.test(text);
+}
+function resolveCanonicalId(model, lookup) {
+  const viaKey = lookup.keyToCanonicalId(model);
+  if (viaKey !== undefined)
+    return viaKey;
+  if (lookup.rowsForCanonicalId(model).length > 0)
+    return model;
+  return;
+}
+function validateModelSlots(raw, lookup) {
+  if (!Array.isArray(raw)) {
+    return { ok: false, reason: `"modelSlots" must be an array, got ${raw === null ? "null" : typeof raw}` };
+  }
+  if (raw.length === 0) {
+    return { ok: false, reason: `"modelSlots" must contain at least one entry (1–${MAX_SLOTS}, WS-13c §5)` };
+  }
+  if (raw.length > MAX_SLOTS) {
+    return { ok: false, reason: `"modelSlots" must contain at most four entries (got ${raw.length})` };
+  }
+  const slots = [];
+  const seenNames = new Set;
+  for (let i = 0;i < raw.length; i++) {
+    const entry = raw[i];
+    const where = `modelSlots[${i}]`;
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      return { ok: false, reason: `${where} must be an object, got ${entry === null ? "null" : Array.isArray(entry) ? "an array" : typeof entry}` };
+    }
+    const record = entry;
+    const { name, model, provider, description } = record;
+    if (typeof name !== "string" || !SLOT_NAME_RE.test(name)) {
+      return { ok: false, reason: `${where}.name must match the slot name grammar (${SLOT_NAME_RE.source}), got ${JSON.stringify(name)}` };
+    }
+    if (CLAUDE_RESERVED_SLOT_NAMES.includes(name)) {
+      return { ok: false, reason: `${where}.name ${JSON.stringify(name)} is reserved to the claude family (${CLAUDE_RESERVED_SLOT_NAMES.join(", ")}) and cannot be used as a custom slot name` };
+    }
+    if (seenNames.has(name)) {
+      return { ok: false, reason: `${where}.name ${JSON.stringify(name)} is a duplicate slot name` };
+    }
+    seenNames.add(name);
+    if (typeof model !== "string" || model.length === 0) {
+      return { ok: false, reason: `${where}.model must be a non-empty string, got ${JSON.stringify(model)}` };
+    }
+    const canonicalId = resolveCanonicalId(model, lookup);
+    const rows = canonicalId !== undefined ? lookup.rowsForCanonicalId(canonicalId) : [];
+    if (canonicalId === undefined || rows.length === 0) {
+      return { ok: false, reason: `${where}.model ${JSON.stringify(model)} has no catalog row (not a known catalog key or canonical model id with a servable row)` };
+    }
+    if (provider !== undefined) {
+      if (typeof provider !== "string" || provider.length === 0) {
+        return { ok: false, reason: `${where}.provider must be a non-empty string, got ${JSON.stringify(provider)}` };
+      }
+      if (!rows.some((row) => row.providerId === provider)) {
+        const servedBy = rows.map((row) => row.providerId);
+        return { ok: false, reason: `${where}.provider ${JSON.stringify(provider)} does not serve ${JSON.stringify(model)} (served by: ${servedBy.length > 0 ? servedBy.join(", ") : "nobody"})` };
+      }
+    }
+    if (description !== undefined) {
+      if (typeof description !== "string") {
+        return { ok: false, reason: `${where}.description must be a string, got ${typeof description}` };
+      }
+      if (description.length > MAX_DESCRIPTION_LENGTH) {
+        return { ok: false, reason: `${where}.description exceeds ${MAX_DESCRIPTION_LENGTH} characters (got ${description.length})` };
+      }
+      if (hasCurrencyAmount(description)) {
+        return { ok: false, reason: `${where}.description must not carry a currency amount (pricing lives on catalog rows), got ${JSON.stringify(description)}` };
+      }
+    }
+    slots.push({
+      name,
+      model,
+      ...provider !== undefined ? { provider } : {},
+      ...description !== undefined ? { description } : {}
+    });
+  }
+  return { ok: true, slots };
+}
+// src/permissions/types.ts
+var HOOK_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "UserPromptSubmit",
+  "Stop",
+  "SubagentStart",
+  "SubagentStop",
+  "PreCompact",
+  "PermissionRequest",
+  "Notification",
+  "PostToolBatch",
+  "UserPromptExpansion",
+  "MessageDisplay",
+  "StopFailure",
+  "PostCompact",
+  "PermissionDenied",
+  "SessionStart",
+  "SessionEnd",
+  "Setup",
+  "TeammateIdle",
+  "TaskCreated",
+  "TaskCompleted",
+  "Elicitation",
+  "ElicitationResult",
+  "ConfigChange",
+  "InstructionsLoaded",
+  "WorktreeCreate",
+  "WorktreeRemove",
+  "CwdChanged",
+  "FileChanged",
+  "DirectoryAdded"
+];
+export {
+  AbortError,
+  BRAND_TOKEN_RE,
+  CLIConnectionError,
+  DEFAULT_COMPACTION_THRESHOLD,
+  DEFAULT_CONTEXT_WINDOW_TOKENS,
+  DEFAULT_KEYCHAIN_SERVICE,
+  DEFAULT_OUTPUT_STYLE,
+  DEFAULT_PLANS_DIRECTORY,
+  DEFAULT_PROVIDER_STALL_TIMEOUT_MS,
+  DIALECT_RECORD_ENTRY_TYPE,
+  ESCALATING_PERMISSION_MODES,
+  FIRST_PARTY_ORIGINATORS,
+  HOOK_EVENTS,
+  InvalidBrandError,
+  OVERLAY_NEVER_KEYS,
+  PROJECT_PERMISSIVE_KEYS,
+  PROTOCOL_VERSION,
+  PROVIDER_STATE_FILE_SUFFIX,
+  ProcessError,
+  ProtocolDecodeError,
+  ProtocolError,
+  ResultError,
+  SETTING_SOURCES,
+  SYSTEM_PROMPT_DYNAMIC_BOUNDARY,
+  SessionNotFoundError,
+  WINTER_BRAND,
+  WinterCompatibilitySessionStore,
+  WinterRpcError,
+  WinterRpcTimeoutError,
+  WinterSDKError,
+  WinterStoreError,
+  WinterStoreLeaseError,
+  applyWorkspaceTrust,
+  compatibilityKeys,
+  decodeFrame,
+  defaultSpawn,
+  deleteSession,
+  encodeFrame,
+  envName,
+  filterEscalatingDefaultMode,
+  forkSession,
+  forkSessionByKey,
+  getSessionInfo,
+  getSessionMessages,
+  getSubagentMessages,
+  isUnset,
+  isWinterMcpServerInstance,
+  listSessions,
+  listSubagents,
+  loadSettingsFile,
+  mcpToolName,
+  providerSettingsFrom,
+  query,
+  renameSession,
+  resolveBrand,
+  resolveKeychainServiceForProfile,
+  resolveRuntimeExecutable,
+  resolveSettings,
+  resolveSettingsDetailed,
+  resolveWinterHome,
+  settingsPathFor,
+  splitFrames,
+  tagSession,
+  transcriptProjectKey,
+  userAgent,
+  validateModelSlots
+};