@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-e54b9byn.js

@@ -0,0 +1,633 @@
+import {
+  PositiveInt2
+} from "./worktree-922hggd3.js";
+import {
+  Action2
+} from "./worktree-g190xswt.js";
+import {
+  Info14
+} from "./worktree-16cax9zb.js";
+import {
+  Info12
+} from "./worktree-t0fxg8b9.js";
+import {
+  Info17
+} from "./worktree-fm2qvscf.js";
+import {
+  Info20
+} from "./worktree-ead3g9p8.js";
+import {
+  Spec2
+} from "./worktree-qgn6gcr1.js";
+import {
+  Info15
+} from "./worktree-wbkyxrgf.js";
+import {
+  Info11
+} from "./worktree-5k6pxcn0.js";
+import {
+  migrate2,
+  normalizeAction2,
+  migrateAgent2,
+  commands2,
+  migrateMcp2,
+  migrateProvider2,
+  providerID2
+} from "./worktree-4vfmzcq2.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/config/normalize.ts
+var exports_normalize = {};
+__export(exports_normalize, {
+  ConfigNormalize: () => exports_normalize,
+  normalize: () => normalize2
+});
+import { isDeepStrictEqual } from "node:util";
+import { isRecord } from "@opencode/ai/utils/record";
+import { Option, Schema } from "effect";
+import { Info } from "@opencode/schema/config";
+import { ConfigAgent } from "@opencode/schema/config/agent";
+import { ConfigCommand } from "@opencode/schema/config/command";
+import { ConfigCompaction } from "@opencode/schema/config/compaction";
+import { ConfigFormatter } from "@opencode/schema/config/formatter";
+import { ConfigLSP } from "@opencode/schema/config/lsp";
+import { ConfigMedia } from "@opencode/schema/config/media";
+import { ConfigMCP } from "@opencode/schema/config/mcp";
+import { ConfigPlugin } from "@opencode/schema/config/plugin";
+import { ConfigPolicy } from "@opencode/schema/config/policy";
+import { ConfigProvider } from "@opencode/schema/config/provider";
+import { ConfigReference } from "@opencode/schema/config/reference";
+import { ConfigExperimental } from "@opencode/schema/config/experimental";
+import { Permission } from "@opencode/schema/permission";
+var options = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" };
+var unsupportedTopLevel = ["logLevel", "server", "subagent_depth", "layout"];
+var unsupportedExperimental = [
+  "disable_paste_summary",
+  "batch_tool",
+  "openTelemetry",
+  "primary_tools",
+  "continue_loop_on_deny"
+];
+var unsupportedProvider = ["id", "whitelist", "blacklist"];
+var unsupportedModel = ["release_date", "attachment", "reasoning", "temperature", "experimental"];
+function normalize2(input) {
+  if (!isRecord(input))
+    return {
+      type: "rejected",
+      diagnostics: [
+        { kind: "invalid", path: ["$"], message: "rejected configuration because its root is not an object" }
+      ]
+    };
+  const diagnostics = [];
+  const encoded = {};
+  unsupportedTopLevel.forEach((key) => unsupportedIfPresent(input, key, [key], diagnostics));
+  const legacySnapshots = own(input, "snapshot") ? decodeEncoded(Schema.Boolean, input.snapshot, ["snapshot"], diagnostics) : undefined;
+  const legacyUpdate = own(input, "autoupdate") ? decodeValue(Info11.fields.autoupdate, input.autoupdate, ["autoupdate"], diagnostics) : undefined;
+  const nativeUpdate = own(input, "update") ? decodeEncoded(Info.fields.update, input.update, ["update"], diagnostics) : undefined;
+  const legacyShare = own(input, "autoshare") ? decodeValue(Schema.Boolean, input.autoshare, ["autoshare"], diagnostics) === true ? "auto" : undefined : undefined;
+  const legacyMedia = own(input, "attachment") ? decodeValue(Info12, input.attachment, ["attachment"], diagnostics) : undefined;
+  if (legacyMedia !== undefined) {
+    const migrated = migrate2({ attachment: legacyMedia }).media;
+    if (migrated !== undefined)
+      encoded.media = canonical(ConfigMedia.Info, migrated);
+  }
+  if (legacySnapshots !== undefined)
+    encoded.snapshots = legacySnapshots;
+  const migratedUpdate = legacyUpdate === undefined ? undefined : migrate2({ autoupdate: legacyUpdate }).update;
+  const update = prefer(migratedUpdate, nativeUpdate, ["update"], diagnostics);
+  if (update !== undefined)
+    encoded.update = update;
+  if (legacyShare !== undefined)
+    encoded.share = legacyShare;
+  const legacyReferences = decodeMap(input.reference, ConfigReference.Entry, ["reference"], diagnostics, decodeEncoded);
+  const nativeReferences = decodeMap(input.references, ConfigReference.Entry, ["references"], diagnostics, decodeEncoded);
+  mergeMap(encoded, "references", legacyReferences, nativeReferences, isRecord(input.reference) || isRecord(input.references), diagnostics);
+  const legacyCommands = decodeMap(input.command, Info17, ["command"], diagnostics, decodeValue);
+  diagnoseSelectionMap(input.command, ["command"], diagnostics);
+  const migratedCommands = mapValues(legacyCommands, (value) => {
+    const migrated = commands2({ value })?.value;
+    return migrated === undefined ? undefined : canonical(ConfigCommand.Info, migrated);
+  });
+  const nativeCommands = decodeMap(input.commands, ConfigCommand.Info, ["commands"], diagnostics, decodeEncoded);
+  mergeMap(encoded, "commands", migratedCommands, nativeCommands, isRecord(input.command) || isRecord(input.commands), diagnostics);
+  const legacyAgents = mapValues(decodeMap(input.agent, Info14, ["agent"], diagnostics, decodeValue), (value) => canonical(ConfigAgent.Info, migrateAgent2(value)));
+  const legacySmallModel = own(input, "small_model") ? decodeValue(Schema.String, input.small_model, ["small_model"], diagnostics) : undefined;
+  const migratedSmallModel = legacySmallModel ? migrate2({ small_model: legacySmallModel }).agents?.title?.model : undefined;
+  if (legacySmallModel && !migratedSmallModel)
+    diagnostics.push({
+      kind: "unsupported",
+      path: ["small_model"],
+      message: "omitted unsupported legacy model reference"
+    });
+  if (migratedSmallModel)
+    legacyAgents.title = {
+      model: migratedSmallModel,
+      ...legacyAgents.title
+    };
+  const modeAgents = mapValues(decodeMap(input.mode, Info14, ["mode"], diagnostics, decodeValue), (value) => canonical(ConfigAgent.Info, migrateAgent2({ ...value, mode: "primary" })));
+  const migratedAgents = mergeMaps(legacyAgents, modeAgents, ["agents"], diagnostics);
+  const nativeAgents = decodeMap(input.agents, ConfigAgent.Info, ["agents"], diagnostics, decodeEncoded);
+  diagnoseAgentUnsupported(input.agent, ["agent"], diagnostics);
+  diagnoseAgentUnsupported(input.mode, ["mode"], diagnostics);
+  mergeMap(encoded, "agents", migratedAgents, nativeAgents, migratedSmallModel !== undefined || isRecord(input.agent) || isRecord(input.mode) || isRecord(input.agents), diagnostics);
+  const legacyProviders = migrateProviders(input.provider, diagnostics);
+  const nativeProviders = decodeMap(input.providers, ConfigProvider.Info, ["providers"], diagnostics, decodeEncoded);
+  mergeMap(encoded, "providers", legacyProviders, nativeProviders, isRecord(input.provider) || isRecord(input.providers), diagnostics);
+  const toolRules = migrateTools(input.tools, diagnostics);
+  const permissionRules = migratePermissions(input.permission, diagnostics);
+  const nativePermissions = decodeList(input.permissions, Permission.Rule, ["permissions"], diagnostics, decodeEncoded);
+  const permissions = [...toolRules, ...permissionRules, ...nativePermissions];
+  if (permissions.length || Array.isArray(input.permissions))
+    encoded.permissions = permissions;
+  const legacyPlugins = decodeList(input.plugin, Spec2, ["plugin"], diagnostics, decodeValue).map((plugin) => typeof plugin === "string" ? plugin : { package: plugin[0], options: plugin[1] });
+  const nativePlugins = decodeList(input.plugins, ConfigPlugin.Plugin, ["plugins"], diagnostics, decodeEncoded);
+  if (legacyPlugins.length || nativePlugins.length || Array.isArray(input.plugin) || Array.isArray(input.plugins))
+    encoded.plugins = [...legacyPlugins, ...nativePlugins];
+  normalizeSkills(input, encoded, diagnostics);
+  normalizeMcp(input, encoded, diagnostics);
+  normalizeCompaction(input, encoded, diagnostics);
+  normalizeExperimental(input, encoded, diagnostics);
+  normalizeWatcher(input, encoded, diagnostics);
+  normalizeFormatter(input, encoded, diagnostics);
+  normalizeLsp(input, encoded, diagnostics);
+  const nativeAtomic = {
+    $schema: Info.fields.$schema,
+    shell: Info.fields.shell,
+    model: Info.fields.model,
+    default_agent: Info.fields.default_agent,
+    share: Info.fields.share,
+    enterprise: Info.fields.enterprise,
+    username: Info.fields.username,
+    snapshots: Info.fields.snapshots,
+    media: Info.fields.media,
+    tool_output: Info.fields.tool_output,
+    websearch: Info.fields.websearch,
+    worktree: Info.fields.worktree,
+    warming: Info.fields.warming
+  };
+  Object.entries(nativeAtomic).forEach(([key, schema]) => {
+    if (!own(input, key))
+      return;
+    const value = decodeEncoded(schema, input[key], [key], diagnostics);
+    if (value === undefined)
+      return;
+    overlay(encoded, key, value, [key], diagnostics);
+  });
+  const instructions = decodeList(input.instructions, Schema.String, ["instructions"], diagnostics, decodeEncoded);
+  if (instructions.length || Array.isArray(input.instructions))
+    encoded.instructions = instructions;
+  return { type: "normalized", encoded, diagnostics };
+}
+function normalizeSkills(input, encoded, diagnostics) {
+  if (!own(input, "skills"))
+    return;
+  if (Array.isArray(input.skills)) {
+    encoded.skills = decodeList(input.skills, Schema.String, ["skills"], diagnostics, decodeEncoded);
+    return;
+  }
+  if (!isRecord(input.skills)) {
+    invalid(["skills"], diagnostics);
+    return;
+  }
+  encoded.skills = [
+    ...decodeList(input.skills.paths, Schema.String, ["skills", "paths"], diagnostics, decodeEncoded),
+    ...decodeList(input.skills.urls, Schema.String, ["skills", "urls"], diagnostics, decodeEncoded)
+  ];
+}
+function normalizeMcp(input, encoded, diagnostics) {
+  const legacyServers = {};
+  const nativeServers = {};
+  const timeout = {};
+  if (isRecord(input.experimental) && own(input.experimental, "mcp_timeout")) {
+    const value = decodeEncoded(PositiveInt2, input.experimental.mcp_timeout, ["experimental", "mcp_timeout"], diagnostics);
+    if (value !== undefined) {
+      timeout.catalog = value;
+      timeout.execution = value;
+    }
+  }
+  if (own(input, "mcp")) {
+    if (!isRecord(input.mcp))
+      invalid(["mcp"], diagnostics);
+    if (isRecord(input.mcp)) {
+      Object.entries(input.mcp).forEach(([name, value]) => {
+        const path = ["mcp", name];
+        if (isEnabledOnlyMcp(value)) {
+          diagnostics.push({ kind: "unsupported", path, message: "omitted enabled-only legacy MCP entry" });
+          return;
+        }
+        if (name === "servers" && !isDirectLegacyMcp(value)) {
+          Object.entries(decodeMap(value, ConfigMCP.Server, path, diagnostics, decodeEncoded)).forEach(([key, server]) => setOwn(nativeServers, key, server));
+          return;
+        }
+        if (name === "timeout" && !isDirectLegacyMcp(value)) {
+          normalizeMcpTimeout(value, timeout, path, diagnostics);
+          return;
+        }
+        const server = decodeValue(Info20, value, path, diagnostics);
+        if (server !== undefined)
+          setOwn(legacyServers, name, canonical(ConfigMCP.Server, migrateMcp2(server)));
+      });
+    }
+  }
+  const servers = mergeMaps(legacyServers, nativeServers, ["mcp", "servers"], diagnostics);
+  if (!Object.keys(servers).length && !Object.keys(timeout).length) {
+    if (isRecord(input.mcp) && !Object.keys(input.mcp).length)
+      encoded.mcp = {};
+    return;
+  }
+  encoded.mcp = {
+    ...Object.keys(timeout).length ? { timeout } : {},
+    ...Object.keys(servers).length ? { servers } : {}
+  };
+}
+function normalizeMcpTimeout(value, timeout, path, diagnostics) {
+  if (!isRecord(value)) {
+    invalid(path, diagnostics);
+    return;
+  }
+  const recognized = Object.entries(ConfigMCP.Timeout.fields).filter(([key]) => own(value, key));
+  if (Object.keys(value).length && !recognized.length) {
+    invalid(path, diagnostics);
+    return;
+  }
+  recognized.forEach(([key, field]) => {
+    const leaf = decodeEncoded(field, value[key], [...path, key], diagnostics);
+    if (leaf === undefined)
+      return;
+    overlay(timeout, key, leaf, [...path, key], diagnostics);
+  });
+}
+function normalizeCompaction(input, encoded, diagnostics) {
+  if (!own(input, "compaction"))
+    return;
+  if (!isRecord(input.compaction)) {
+    invalid(["compaction"], diagnostics);
+    return;
+  }
+  unsupportedIfPresent(input.compaction, "tail_turns", ["compaction", "tail_turns"], diagnostics);
+  unsupportedIfPresent(input.compaction, "prune", ["compaction", "prune"], diagnostics);
+  const result = {};
+  if (own(input.compaction, "auto")) {
+    const value = decodeEncoded(ConfigCompaction.Info.fields.auto, input.compaction.auto, ["compaction", "auto"], diagnostics);
+    if (value !== undefined)
+      result.auto = value;
+  }
+  const legacyTokens = own(input.compaction, "preserve_recent_tokens") ? decodeEncoded(ConfigCompaction.Keep.fields.tokens, input.compaction.preserve_recent_tokens, ["compaction", "preserve_recent_tokens"], diagnostics) : undefined;
+  const nativeKeep = isRecord(input.compaction.keep) ? input.compaction.keep : undefined;
+  if (own(input.compaction, "keep") && !nativeKeep)
+    invalid(["compaction", "keep"], diagnostics);
+  const nativeTokens = nativeKeep && own(nativeKeep, "tokens") ? decodeEncoded(ConfigCompaction.Keep.fields.tokens, nativeKeep.tokens, ["compaction", "keep", "tokens"], diagnostics) : undefined;
+  const tokens = prefer(legacyTokens, nativeTokens, ["compaction", "keep", "tokens"], diagnostics);
+  if (tokens !== undefined)
+    result.keep = { tokens };
+  const legacyBuffer = own(input.compaction, "reserved") ? decodeEncoded(ConfigCompaction.Info.fields.buffer, input.compaction.reserved, ["compaction", "reserved"], diagnostics) : undefined;
+  const nativeBuffer = own(input.compaction, "buffer") ? decodeEncoded(ConfigCompaction.Info.fields.buffer, input.compaction.buffer, ["compaction", "buffer"], diagnostics) : undefined;
+  const buffer = prefer(legacyBuffer, nativeBuffer, ["compaction", "buffer"], diagnostics);
+  if (buffer !== undefined)
+    result.buffer = buffer;
+  if (Object.keys(result).length || !Object.keys(input.compaction).length)
+    encoded.compaction = result;
+}
+function normalizeExperimental(input, encoded, diagnostics) {
+  const result = {};
+  const generated = [];
+  const enabled = decodeProviderList(input, "enabled_providers", diagnostics);
+  if (enabled.present && (!enabled.nonEmpty || enabled.values.length)) {
+    generated.push({ action: "provider.use", resource: "*", effect: "deny" });
+    generated.push(...enabled.values.map((resource) => ({
+      action: "provider.use",
+      resource: providerID2(resource),
+      effect: "allow"
+    })));
+  }
+  const disabled = decodeProviderList(input, "disabled_providers", diagnostics);
+  generated.push(...disabled.values.map((resource) => ({
+    action: "provider.use",
+    resource: providerID2(resource),
+    effect: "deny"
+  })));
+  const native = [];
+  if (own(input, "experimental")) {
+    if (!isRecord(input.experimental))
+      invalid(["experimental"], diagnostics);
+    if (isRecord(input.experimental)) {
+      const experimental = input.experimental;
+      unsupportedExperimental.forEach((key) => unsupportedIfPresent(experimental, key, ["experimental", key], diagnostics));
+      if (own(experimental, "portable_shell_scanner")) {
+        const value = decodeEncoded(ConfigExperimental.Info.fields.portable_shell_scanner, experimental.portable_shell_scanner, ["experimental", "portable_shell_scanner"], diagnostics);
+        if (value !== undefined)
+          result.portable_shell_scanner = value;
+      }
+      if (own(experimental, "subagent_depth")) {
+        const value = decodeEncoded(ConfigExperimental.Info.fields.subagent_depth, experimental.subagent_depth, ["experimental", "subagent_depth"], diagnostics);
+        if (value !== undefined)
+          result.subagent_depth = value;
+      }
+      native.push(...decodeList(experimental.policies, ConfigPolicy.Info, ["experimental", "policies"], diagnostics, decodeEncoded));
+    }
+  }
+  if (generated.length || native.length || isRecord(input.experimental) && Array.isArray(input.experimental.policies))
+    result.policies = [...generated, ...native];
+  if (Object.keys(result).length || isRecord(input.experimental) && !Object.keys(input.experimental).length)
+    encoded.experimental = result;
+}
+function normalizeWatcher(input, encoded, diagnostics) {
+  if (!own(input, "watcher"))
+    return;
+  if (!isRecord(input.watcher)) {
+    invalid(["watcher"], diagnostics);
+    return;
+  }
+  const ignore = decodeList(input.watcher.ignore, Schema.String, ["watcher", "ignore"], diagnostics, decodeEncoded);
+  encoded.watcher = ignore.length || Array.isArray(input.watcher.ignore) ? { ignore } : {};
+}
+function normalizeFormatter(input, encoded, diagnostics) {
+  if (!own(input, "formatter"))
+    return;
+  if (typeof input.formatter === "boolean") {
+    const value = decodeEncoded(ConfigFormatter.Info, input.formatter, ["formatter"], diagnostics);
+    if (value !== undefined)
+      encoded.formatter = value;
+    return;
+  }
+  const entries = decodeMap(input.formatter, ConfigFormatter.Entry, ["formatter"], diagnostics, decodeEncoded);
+  if (isRecord(input.formatter) && (!Object.keys(input.formatter).length || Object.keys(entries).length))
+    encoded.formatter = entries;
+}
+function normalizeLsp(input, encoded, diagnostics) {
+  if (!own(input, "lsp"))
+    return;
+  if (typeof input.lsp === "boolean") {
+    const value = decodeEncoded(ConfigLSP.Info, input.lsp, ["lsp"], diagnostics);
+    if (value !== undefined)
+      encoded.lsp = value;
+    return;
+  }
+  const entries = decodeMap(input.lsp, ConfigLSP.Entry, ["lsp"], diagnostics, decodeEncoded);
+  if (isRecord(input.lsp) && (!Object.keys(input.lsp).length || Object.keys(entries).length))
+    encoded.lsp = entries;
+}
+function migrateTools(value, diagnostics) {
+  if (value === undefined)
+    return [];
+  if (!isRecord(value)) {
+    invalid(["tools"], diagnostics);
+    return [];
+  }
+  return Object.entries(value).flatMap(([action, raw]) => {
+    const enabled = decodeValue(Schema.Boolean, raw, ["tools", action], diagnostics);
+    if (enabled === undefined)
+      return [];
+    return [{ action: normalizeAction2(action), resource: "*", effect: enabled ? "allow" : "deny" }];
+  });
+}
+function migratePermissions(value, diagnostics) {
+  if (value === undefined)
+    return [];
+  if (typeof value === "string") {
+    const effect = decodeValue(Action2, value, ["permission"], diagnostics);
+    return effect === undefined ? [] : [{ action: "*", resource: "*", effect }];
+  }
+  if (!isRecord(value)) {
+    invalid(["permission"], diagnostics);
+    return [];
+  }
+  return Object.entries(value).flatMap(([action, raw]) => {
+    if (typeof raw === "string") {
+      const effect = decodeValue(Action2, raw, ["permission", action], diagnostics);
+      return effect === undefined ? [] : [{ action: normalizeAction2(action), resource: "*", effect }];
+    }
+    if (!isRecord(raw)) {
+      invalid(["permission", action], diagnostics);
+      return [];
+    }
+    return Object.entries(raw).flatMap(([resource, effect], index) => {
+      const decoded = decodeValue(Action2, effect, ["permission", action, String(index)], diagnostics);
+      return decoded === undefined ? [] : [{ action: normalizeAction2(action), resource, effect: decoded }];
+    });
+  });
+}
+function migrateProviders(value, diagnostics) {
+  if (value === undefined)
+    return {};
+  if (!isRecord(value)) {
+    invalid(["provider"], diagnostics);
+    return {};
+  }
+  const candidates = Object.entries(value).flatMap(([name, raw]) => {
+    const path = ["provider", name];
+    diagnoseProviderUnsupported(raw, path, diagnostics);
+    if (invalidProviderOverlays(raw, path, diagnostics))
+      return [];
+    const provider = decodeValue(Info15, raw, path, diagnostics);
+    if (provider === undefined)
+      return [];
+    const destination = providerID2(name);
+    return [
+      {
+        name,
+        destination,
+        provider: canonical(ConfigProvider.Info, migrateProvider2(name, provider))
+      }
+    ];
+  });
+  const current = new Set(candidates.filter((item) => item.name === item.destination).map((item) => item.destination));
+  const result = {};
+  candidates.forEach((item) => {
+    if (item.name !== item.destination && current.has(item.destination))
+      return;
+    setOwn(result, item.destination, item.provider);
+  });
+  return result;
+}
+function invalidProviderOverlays(value, path, diagnostics) {
+  if (!isRecord(value) || !isRecord(value.options))
+    return false;
+  const headersInvalid = own(value.options, "headers") && (!isPlainRecord(value.options.headers) || Object.values(value.options.headers).some((item) => typeof item !== "string"));
+  const bodyInvalid = own(value.options, "body") && !isPlainRecord(value.options.body);
+  if (headersInvalid)
+    invalid([...path, "options", "headers"], diagnostics);
+  if (bodyInvalid)
+    invalid([...path, "options", "body"], diagnostics);
+  return headersInvalid || bodyInvalid;
+}
+function diagnoseProviderUnsupported(value, path, diagnostics) {
+  if (!isRecord(value))
+    return;
+  unsupportedProvider.forEach((key) => unsupportedIfPresent(value, key, [...path, key], diagnostics));
+  if (!isRecord(value.models))
+    return;
+  Object.entries(value.models).forEach(([name, model]) => {
+    if (!isRecord(model))
+      return;
+    unsupportedModel.forEach((key) => unsupportedIfPresent(model, key, [...path, "models", name, key], diagnostics));
+    if (own(model, "status") && model.status !== "deprecated")
+      unsupportedIfPresent(model, "status", [...path, "models", name, "status"], diagnostics);
+    if (own(model, "interleaved") && typeof model.interleaved === "boolean")
+      unsupportedIfPresent(model, "interleaved", [...path, "models", name, "interleaved"], diagnostics);
+  });
+}
+function diagnoseAgentUnsupported(value, path, diagnostics) {
+  if (!isRecord(value))
+    return;
+  Object.entries(value).forEach(([name, agent]) => {
+    if (!isRecord(agent))
+      return;
+    unsupportedIfPresent(agent, "name", [...path, name, "name"], diagnostics);
+    diagnoseSelection(agent, [...path, name], diagnostics);
+  });
+}
+function diagnoseSelectionMap(value, path, diagnostics) {
+  if (!isRecord(value))
+    return;
+  Object.entries(value).forEach(([name, entry]) => {
+    if (isRecord(entry))
+      diagnoseSelection(entry, [...path, name], diagnostics);
+  });
+}
+function diagnoseSelection(value, path, diagnostics) {
+  const modelValid = typeof value.model === "string" && /^[^/#]+\/[^#]+$/.test(value.model);
+  if (own(value, "model") && typeof value.model === "string" && !modelValid)
+    diagnostics.push({
+      kind: "unsupported",
+      path: [...path, "model"],
+      message: "omitted unsupported legacy model reference"
+    });
+  if (own(value, "variant") && typeof value.variant === "string" && (!modelValid || value.variant.length === 0 || value.variant.includes("#")))
+    diagnostics.push({
+      kind: "unsupported",
+      path: [...path, "variant"],
+      message: "omitted unsupported legacy model variant"
+    });
+}
+function decodeProviderList(input, key, diagnostics) {
+  if (!own(input, key))
+    return { present: false, nonEmpty: false, values: [] };
+  if (!Array.isArray(input[key])) {
+    invalid([key], diagnostics);
+    return { present: true, nonEmpty: true, values: [] };
+  }
+  return {
+    present: true,
+    nonEmpty: input[key].length > 0,
+    values: decodeList(input[key], Schema.String, [key], diagnostics, decodeValue)
+  };
+}
+function decodeMap(value, schema, path, diagnostics, decode) {
+  if (value === undefined)
+    return {};
+  if (!isRecord(value)) {
+    invalid(path, diagnostics);
+    return {};
+  }
+  return Object.fromEntries(Object.entries(value).flatMap(([name, raw]) => {
+    const decoded = decode(schema, raw, [...path, name], diagnostics);
+    return decoded === undefined ? [] : [[name, decoded]];
+  }));
+}
+function decodeList(value, schema, path, diagnostics, decode) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value)) {
+    invalid(path, diagnostics);
+    return [];
+  }
+  return value.flatMap((item, index) => {
+    const decoded = decode(schema, item, [...path, String(index)], diagnostics);
+    return decoded === undefined ? [] : [decoded];
+  });
+}
+function decodeValue(schema, value, path, diagnostics) {
+  const decoded = Schema.decodeUnknownOption(schema, options)(value);
+  if (Option.isSome(decoded))
+    return decoded.value;
+  invalid(path, diagnostics);
+  return;
+}
+function decodeEncoded(schema, value, path, diagnostics) {
+  const decoded = Schema.decodeUnknownOption(schema, options)(value);
+  if (Option.isNone(decoded)) {
+    invalid(path, diagnostics);
+    return;
+  }
+  const encoded = Schema.encodeUnknownOption(schema, options)(decoded.value);
+  if (Option.isSome(encoded))
+    return plain(encoded.value);
+  invalid(path, diagnostics);
+  return;
+}
+function canonical(schema, value) {
+  return plain(Option.getOrThrow(Schema.decodeUnknownOption(schema, options)(plain(value)).pipe(Option.flatMap((decoded) => Schema.encodeUnknownOption(schema, options)(decoded)))));
+}
+function plain(value) {
+  if (Array.isArray(value))
+    return value.map(plain);
+  if (!isRecord(value))
+    return value;
+  return Object.fromEntries(Object.entries(value).flatMap(([key, item]) => item === undefined ? [] : [[key, plain(item)]]));
+}
+function mergeMap(target, key, legacy, native, present, diagnostics) {
+  const merged = mergeMaps(legacy, native, [key], diagnostics);
+  if (present)
+    target[key] = merged;
+}
+function mergeMaps(legacy, native, path, diagnostics) {
+  const result = Object.fromEntries(Object.entries(legacy));
+  Object.entries(native).forEach(([name, value]) => {
+    if (own(result, name) && !isDeepStrictEqual(result[name], value))
+      conflict([...path, name], diagnostics);
+    setOwn(result, name, value);
+  });
+  return result;
+}
+function mapValues(input, map) {
+  return Object.fromEntries(Object.entries(input).flatMap(([key, value]) => {
+    const mapped = map(value);
+    return mapped === undefined ? [] : [[key, mapped]];
+  }));
+}
+function overlay(target, key, value, path, diagnostics) {
+  if (own(target, key) && !isDeepStrictEqual(target[key], value))
+    conflict(path, diagnostics);
+  target[key] = value;
+}
+function prefer(legacy, native, path, diagnostics) {
+  if (native === undefined)
+    return legacy;
+  if (legacy !== undefined && !isDeepStrictEqual(legacy, native))
+    conflict(path, diagnostics);
+  return native;
+}
+function unsupportedIfPresent(value, key, path, diagnostics) {
+  if (!own(value, key))
+    return;
+  diagnostics.push({ kind: "unsupported", path, message: "omitted unsupported legacy setting" });
+}
+function invalid(path, diagnostics) {
+  diagnostics.push({ kind: "invalid", path, message: "skipped malformed recognized value" });
+}
+function conflict(path, diagnostics) {
+  diagnostics.push({ kind: "conflict", path, message: "retained native value over legacy value" });
+}
+function isDirectLegacyMcp(value) {
+  return isRecord(value) && (value.type === "local" || value.type === "remote");
+}
+function isEnabledOnlyMcp(value) {
+  return isRecord(value) && !own(value, "type") && typeof value.enabled === "boolean";
+}
+function isPlainRecord(value) {
+  if (!isRecord(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function own(value, key) {
+  return Object.hasOwn(value, key);
+}
+function setOwn(value, key, item) {
+  Object.defineProperty(value, key, { value: item, enumerable: true, configurable: true, writable: true });
+}
+
+export { normalize2, exports_normalize };

package/dist/chunks/worktree-e5kj55wp.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260507164347_add_workspace_time.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260507164347_add_workspace_time",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`time_used\` integer NOT NULL DEFAULT 0;`);
+    });
+  }
+};
+var _20260507164347_add_workspace_time_default = migration;
+
+export { _20260507164347_add_workspace_time_default };

package/dist/chunks/worktree-e73j6tqm.js

@@ -0,0 +1,38 @@
+// src/github-copilot/responses/tool/file-search.ts
+import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var comparisonFilterSchema = z.object({
+  key: z.string(),
+  type: z.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+  value: z.union([z.string(), z.number(), z.boolean()])
+});
+var compoundFilterSchema = z.object({
+  type: z.enum(["and", "or"]),
+  filters: z.array(z.union([comparisonFilterSchema, z.lazy(() => compoundFilterSchema)]))
+});
+var fileSearchArgsSchema2 = z.object({
+  vectorStoreIds: z.array(z.string()),
+  maxNumResults: z.number().optional(),
+  ranking: z.object({
+    ranker: z.string().optional(),
+    scoreThreshold: z.number().optional()
+  }).optional(),
+  filters: z.union([comparisonFilterSchema, compoundFilterSchema]).optional()
+});
+var fileSearchOutputSchema2 = z.object({
+  queries: z.array(z.string()),
+  results: z.array(z.object({
+    attributes: z.record(z.string(), z.unknown()),
+    fileId: z.string(),
+    filename: z.string(),
+    score: z.number(),
+    text: z.string()
+  })).nullable()
+});
+var fileSearch2 = createProviderToolFactoryWithOutputSchema({
+  id: "openai.file_search",
+  inputSchema: z.object({}),
+  outputSchema: fileSearchOutputSchema2
+});
+
+export { fileSearchArgsSchema2, fileSearchOutputSchema2, fileSearch2 };