@matamt-dbg/dsh-studio 0.0.0-stage → 0.2.0

package/index.js

@@ -0,0 +1,1195 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array2, target) => __defNormalProp(target, __knownSymbol("metadata"), array2[3]);
+var __runInitializers = (array2, flags, self, value) => {
+  for (var i = 0, fns = array2[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array2, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array2.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array2[j - 1] = []), extraInitializers = array2[j] || (array2[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array2[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array2, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/package-name.ts
+var PACKAGE_NAME = "@matamt-dbg/dsh-studio";
+var LEGACY_PACKAGE_NAME = "@local/dsh-studio-shell";
+var POLICY_PLUGIN = `${PACKAGE_NAME}/policy`;
+var ROLE_PLUGIN = `${PACKAGE_NAME}/roles`;
+var BATCH_PLUGIN = `${PACKAGE_NAME}/batch`;
+function currentPluginName(name) {
+  return name === LEGACY_PACKAGE_NAME || name.startsWith(`${LEGACY_PACKAGE_NAME}/`) ? PACKAGE_NAME + name.slice(LEGACY_PACKAGE_NAME.length) : name;
+}
+
+// src/delegation.ts
+var ROLE_TOOL = "subagent_role";
+var LEGACY_ROLE_TOOL = "studio_role";
+var GENERIC_DELEGATION_TOOLS = ["subagent", "subagent_fork", "list_subagent_models"];
+var SUBAGENT_PLUGIN = "@deepseek-ai/dsh-tool-subagent";
+var WITHDRAWN_TOOLS = ["task_run"];
+function delegationTools(tools, hasRoles = false) {
+  const delegates = hasRoles || tools.some((name) => name === ROLE_TOOL || name === LEGACY_ROLE_TOOL || GENERIC_DELEGATION_TOOLS.includes(name));
+  const rest = tools.filter((name) => name !== ROLE_TOOL && name !== LEGACY_ROLE_TOOL && !GENERIC_DELEGATION_TOOLS.includes(name) && !WITHDRAWN_TOOLS.includes(name));
+  return delegates ? [...rest, ROLE_TOOL] : rest;
+}
+function withoutDelegationPlugins(rows) {
+  return rows.filter((row) => row.name !== SUBAGENT_PLUGIN && row.name !== ROLE_PLUGIN).map((row) => row.group && Array.isArray(row.config) ? { ...row, config: withoutDelegationPlugins(row.config) } : row);
+}
+function renameLegacyRoleKey(entries) {
+  if (!entries || !Object.hasOwn(entries, LEGACY_ROLE_TOOL)) return entries;
+  const { [LEGACY_ROLE_TOOL]: legacy, ...rest } = entries;
+  return Object.hasOwn(rest, ROLE_TOOL) ? rest : { ...rest, [ROLE_TOOL]: legacy };
+}
+function migratePolicyConfig(config) {
+  const tools = Array.isArray(config.tools) ? config.tools : [];
+  if (!tools.includes(LEGACY_ROLE_TOOL)) return config;
+  const execution = config.execution;
+  return {
+    ...config,
+    tools: [...new Set(tools.map((name) => name === LEGACY_ROLE_TOOL ? ROLE_TOOL : name))],
+    ...config.toolOverrides ? { toolOverrides: renameLegacyRoleKey(config.toolOverrides) } : {},
+    ...execution?.defaults ? { execution: { ...execution, defaults: renameLegacyRoleKey(execution.defaults) } } : {}
+  };
+}
+
+// src/optimized-preset.ts
+var OPTIMIZED_PRESET_ID = "studio-optimized";
+var BUILTIN_TOOL_PRESETS = ["standard", "ptc", "minimal", "cordis"];
+var excluded = /* @__PURE__ */ new Set(["get_goal", "create_goal", "update_goal", "todo_write", "task_run", "cordis_inspect_list", "cordis_inspect_query", "plugin_manager"]);
+var OPTIMIZED_PROMPT = `Use glob to discover paths, grep to search contents, and read to inspect files before editing. Prefer targeted edits.
+Batch independent read-only inspections with read_batch. Start independent tool calls together; keep calls that depend on earlier results sequential. Do not guess unknown arguments.
+Wait for required work to finish before validating it. Use background execution only for independent work or intentionally long-lived services. Do not duplicate running work or busy-poll it.
+Track every job you start. Before reporting completion, collect all relevant results and cancel work that no longer matters. Report failures and unverified behavior honestly.
+Delegate self-contained independent work when useful and collect the result before relying on it.
+Keep changes within the requested scope and preserve user work. Use the smallest sufficient checks for the requested outcome and risk, then stop when the work is complete.`;
+function optimizedTemplate(tools) {
+  const selected = delegationTools(tools.filter((name) => !excluded.has(name)));
+  const request = {
+    preset: "studio-master",
+    providers: ["@deepseek-ai/dsh-persona"],
+    tools: selected,
+    prompt: OPTIMIZED_PROMPT,
+    model: "testLLM",
+    configOverrides: { "spill-policy": { maxInlineTokens: 2500 } },
+    toolOverrides: {
+      ...selected.includes("bash") ? { bash: { parameters: {
+        timeoutMs: "Foreground wait in milliseconds; defaults to a 600000ms request, subject to the runtime cap. When the next step needs the result, request sufficient waiting initially rather than a short wait followed immediately by polling.",
+        run_in_background: "Run in the background immediately only for concrete independent work or intentionally long-lived services. Collect relevant results before relying on success."
+      } } } : {},
+      ...selected.includes("job_output") ? { job_output: { parameters: {
+        wait: "Block until completion or the wait expires. Use true when the result is required and no independent work remains; avoid repeated non-blocking checks. Defaults to false.",
+        timeout_ms: "Maximum wait in milliseconds when wait is true. Defaults to a 120000ms request, subject to the runtime cap. Timeout leaves the job running."
+      } } } : {}
+    },
+    execution: { defaults: { ...selected.includes("bash") ? { bash: { timeoutMs: 6e5 } } : {}, ...selected.includes("job_output") ? { job_output: { timeout_ms: 12e4 } } : {} } }
+  };
+  const missing = ["read_batch"].filter((name) => !selected.includes(name));
+  return {
+    id: OPTIMIZED_PRESET_ID,
+    name: "Optimized",
+    description: "Studio optimized default preset",
+    nonDeletable: true,
+    template: true,
+    status: "applied",
+    agents: [],
+    request,
+    ...missing.length ? { applyWarning: `Optional tool providers not installed: ${missing.join(", ")}. The preset does not install or emulate these tools.` } : {}
+  };
+}
+
+// src/host/shell.ts
+import { createConfigProjector, isNativeConfigSchema, LOADER_EXPRESSION_SCHEMA } from "@deepseek-ai/dsh-app-boot";
+
+// src/config-overrides.ts
+var object = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+function validateConfigOverrides(value) {
+  if (!object(value)) throw new Error("Config overrides must be an object");
+  const visit = (v, depth = 0) => {
+    if (depth > 32) throw new Error("Config nesting exceeds 32");
+    if (typeof v === "number" && !Number.isFinite(v)) throw new Error("Invalid Config number");
+    if (v !== null && !["object", "string", "number", "boolean"].includes(typeof v)) throw new Error("Config must be JSON");
+    if (Array.isArray(v)) v.forEach((child) => visit(child, depth + 1));
+    else if (object(v)) for (const [key, child] of Object.entries(v)) {
+      if (["__proto__", "prototype", "constructor"].includes(key)) throw new Error("Unsafe Config key");
+      visit(child, depth + 1);
+    }
+  };
+  for (const patch of Object.values(value)) {
+    if (!object(patch)) throw new Error("Plugin override must be an object");
+    visit(patch);
+  }
+}
+function mergeConfig(base, patch) {
+  const next = { ...object(base) ? base : {} };
+  for (const [key, value] of Object.entries(patch)) next[key] = object(value) ? mergeConfig(next[key], value) : structuredClone(value);
+  return next;
+}
+function configEntries(rows, parent = "") {
+  return rows.flatMap((row) => {
+    if (!row.id) throw new Error("Master entries require stable ids");
+    const id = parent ? `${parent}/${row.id}` : row.id;
+    return row.group && Array.isArray(row.config) ? configEntries(row.config, id) : [{ id, row }];
+  });
+}
+function applyConfigOverrides(rows, overrides) {
+  validateConfigOverrides(overrides);
+  if (!Object.keys(overrides).length) return structuredClone(rows);
+  const entries = new Map(configEntries(rows).map((entry) => [entry.id, entry.row]));
+  for (const id of Object.keys(overrides)) if (!entries.has(id)) throw new Error(`Unknown master Config entry: ${id}`);
+  const visit = (items, parent = "") => items.map((row) => {
+    const id = parent ? `${parent}/${row.id}` : row.id;
+    return { ...row, ...row.group && Array.isArray(row.config) ? { config: visit(row.config, id) } : overrides[id] ? { config: mergeConfig(row.config, overrides[id]) } : {} };
+  });
+  return visit(rows);
+}
+
+// src/host/master-composition.ts
+var plugin = (id, config, suffix = id) => ({ id, name: `@deepseek-ai/dsh-${suffix}`, ...config ? { config } : {} });
+function masterComposition() {
+  return [
+    plugin("persona", { prefix: "You are a coding agent powered by the {{model}} model." }),
+    plugin("agent-instructions", { maxBytes: 65536 }),
+    plugin("time-context"),
+    plugin(process.platform === "win32" ? "tool-pwsh" : "tool-bash"),
+    plugin("spill-policy"),
+    { id: "studio-batch", name: BATCH_PLUGIN },
+    // task_run (the /tasks entry) is withheld from the Master for now; the provider stays packaged.
+    plugin("tool-fs"),
+    plugin("tool-fs-search", { sampleOverCapGlobResults: false }),
+    plugin("tool-jobs"),
+    plugin("skill-filesystem"),
+    plugin("tool-skill"),
+    plugin("command-goal"),
+    plugin("tool-goal"),
+    { id: "planning", name: "cordis:group", group: true, isolate: { planMode: true }, config: [plugin("plan-mode", { section: "You are in plan mode. Explore with read-only operations and present a complete plan using exit_plan_mode. Do not modify files, execute mutations, or leave plan mode until the user approves the plan or switches modes." })] },
+    { id: "compaction", name: "cordis:group", group: true, isolate: { compaction: true, toolResultPruner: true }, config: [plugin("compaction-basic"), plugin("command-compact"), plugin("tool-result-pruner", { thresholdChars: 8192, headChars: 4096, tailChars: 1024 }, "compaction-tool-result-pruner")] },
+    { id: "delegation", name: "cordis:group", group: true, isolate: { workflowEngine: true }, config: [
+      plugin("tool-subagent-control"),
+      plugin("tool-subagent-list-agents", void 0, "tool-subagent-control/list-agents"),
+      plugin("tool-subagent", { provider: "spawn", toolName: "subagent", modelSelectionSettings: true, toolFilter: { deny: ["schedule_create", "schedule_delete", "schedule_list", "schedule_update"] } }),
+      plugin("tool-subagent-fork", { provider: "fork", toolName: "subagent_fork", toolFilter: { deny: ["schedule_create", "schedule_delete", "schedule_list", "schedule_update"] } }, "tool-subagent"),
+      plugin("workflow-ptc", { provider: "spawn" }),
+      plugin("tool-workflow"),
+      // Catalog source for subagent_role; Studio presets replace the generic subagent tools above with it.
+      { id: "studio-master-roles", name: ROLE_PLUGIN, config: { roles: [] } }
+    ] },
+    plugin("tool-ask-user"),
+    plugin("tool-todo", { allowParallelInProgress: true }),
+    plugin("tool-web", { fetch: true, searchTimeoutMs: 6e4 }),
+    plugin("tool-present"),
+    plugin("tool-cordis"),
+    plugin("tool-plugin-manager", void 0, "plugin-manager/tools")
+  ];
+}
+
+// src/host/master-extensions.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+var poison = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var rowKeys = /* @__PURE__ */ new Set(["id", "name", "group", "config", "disabled", "isolate"]);
+var idPattern = /^[a-z][a-z0-9-]{0,63}$/;
+var packagePattern = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*(?:\/[a-z0-9][a-z0-9._-]*)*$/;
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function keys(value) {
+  const result = [];
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string" || poison.has(key)) throw new Error("Unsafe extension key");
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor) || !descriptor.enumerable && !(Array.isArray(value) && key === "length")) {
+      throw new Error("Extensions must contain JSON data only");
+    }
+    result.push(key);
+  }
+  return result;
+}
+function array(value) {
+  if (!Array.isArray(value)) throw new Error("Expected an extension array");
+  const own3 = keys(value);
+  if (own3.length !== value.length + 1 || own3.some((key) => key !== "length" && !/^(0|[1-9][0-9]*)$/.test(key))) {
+    throw new Error("Extensions must contain dense JSON arrays");
+  }
+}
+function json(value, depth = 0, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "object" || value === null || !Array.isArray(value) && !record(value)) {
+    throw new Error("Extensions must contain JSON data only");
+  }
+  if (depth >= 8 || ancestors.has(value)) throw new Error("Extension config exceeds depth 8 or is cyclic");
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      array(value);
+      return value.map((item) => json(item, depth + 1, ancestors));
+    }
+    return Object.fromEntries(keys(value).map((key) => [key, json(value[key], depth + 1, ancestors)]));
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function validateExtensions(value) {
+  let count = 0;
+  function visit(input, depth) {
+    array(input);
+    if (depth > 8) throw new Error("Extensions exceed depth 8");
+    const ids = /* @__PURE__ */ new Set();
+    return input.map((value2) => {
+      if (++count > 64) throw new Error("Extensions exceed 64 entries");
+      if (!record(value2)) throw new Error("Invalid extension row");
+      const own3 = keys(value2);
+      if (own3.some((key) => !rowKeys.has(key))) throw new Error("Unsupported extension row key");
+      if (typeof value2.id !== "string" || !idPattern.test(value2.id)) throw new Error("Invalid extension id");
+      if (ids.has(value2.id)) throw new Error("Duplicate sibling extension id");
+      ids.add(value2.id);
+      if (typeof value2.name !== "string" || value2.name !== "cordis:group" && !packagePattern.test(value2.name)) {
+        throw new Error("Invalid extension package name");
+      }
+      if (own3.includes("group") && typeof value2.group !== "boolean") throw new Error("Invalid extension group");
+      if (value2.name === "cordis:group" !== (value2.group === true)) throw new Error("cordis:group requires group: true");
+      if (own3.includes("disabled") && typeof value2.disabled !== "boolean") throw new Error("Invalid extension disabled flag");
+      if (own3.includes("isolate")) {
+        const isolate = value2.isolate;
+        if (!record(isolate) || keys(isolate).some((key) => typeof isolate[key] !== "boolean")) {
+          throw new Error("Extension isolate must map service names to booleans");
+        }
+      }
+      const row = { id: value2.id, name: value2.name };
+      if (own3.includes("group")) row.group = value2.group;
+      if (own3.includes("disabled")) row.disabled = value2.disabled;
+      if (own3.includes("isolate")) row.isolate = json(value2.isolate);
+      if (value2.group === true) row.config = visit(value2.config, depth + 1);
+      else if (own3.includes("config")) row.config = json(value2.config);
+      return row;
+    });
+  }
+  return visit(value, 1);
+}
+var MasterExtensions = class {
+  file;
+  tail = Promise.resolve();
+  constructor(file) {
+    this.file = resolve(file);
+  }
+  async read() {
+    await this.tail;
+    let content;
+    try {
+      content = await readFile(this.file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return [];
+      throw error;
+    }
+    const value = JSON.parse(content);
+    if (!record(value) || keys(value).some((key) => !["version", "extensions"].includes(key)) || value.version !== 1) {
+      throw new Error("Unsupported Studio master extensions store");
+    }
+    return validateExtensions(value.extensions);
+  }
+  async save(rows) {
+    const content = JSON.stringify({ version: 1, extensions: validateExtensions(rows) }, null, 2);
+    const operation = this.tail.then(async () => {
+      const directory = dirname(this.file);
+      const temp = resolve(`${this.file}.${randomUUID()}.tmp`);
+      const verify = () => {
+        if (resolve(this.file) !== this.file || dirname(temp) !== directory || temp === this.file) {
+          throw new Error("Invalid master extensions persistence paths");
+        }
+      };
+      verify();
+      await mkdir(directory, { recursive: true, mode: 448 });
+      let created = false;
+      try {
+        await writeFile(temp, content, { mode: 384, flag: "wx" });
+        created = true;
+        verify();
+        await rename(temp, this.file);
+      } finally {
+        if (created) {
+          verify();
+          await unlink(temp).catch((error) => {
+            if (error.code !== "ENOENT") throw error;
+          });
+        }
+      }
+    });
+    this.tail = operation.catch(() => {
+    });
+    return operation;
+  }
+};
+
+// src/host/shell.ts
+import { dirname as dirname3, join as join2 } from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+
+// src/tool-prompt-sections.ts
+var toolPromptSections = {
+  bash: ["tool:bash"],
+  pwsh: ["tool:pwsh"],
+  read: ["tool:read"],
+  write: ["tool:write"],
+  edit: ["tool:edit"],
+  glob: ["tool:glob"],
+  grep: ["tool:grep"],
+  job_list: ["tool:jobs"],
+  job_output: ["tool:jobs"],
+  job_kill: ["tool:jobs"],
+  web_fetch: ["tool:web_fetch"],
+  web_search: ["tool:web_search"],
+  get_goal: ["tool:goal"],
+  create_goal: ["tool:goal"],
+  update_goal: ["tool:goal"]
+};
+
+// src/preset-catalog.ts
+async function readPresetCatalog(services) {
+  const all = new Map(services.tools.schemas().map((tool) => [tool.name, { name: tool.name, description: tool.description, ...tool.parameters ? { parameters: tool.parameters } : {} }]));
+  const presets = [];
+  for (const preset of await services.agentPresets.list()) {
+    let lease;
+    try {
+      lease = await services.agentPresets.acquireScope(preset.id);
+      const assembly = await services.systemPrompt.assemble({ scope: lease.key });
+      for (const tool of [...services.tools.schemas(lease.key), ...assembly.tools]) all.set(tool.name, { name: tool.name, description: tool.description, ...tool.parameters ? { parameters: tool.parameters } : {} });
+      const declaration = (await services.agentPresets.readDocument(preset.id)).content;
+      const tools = new Map([...services.tools.schemas(lease.key), ...assembly.tools].map(({ name, description, parameters }) => [name, { name, description, ...parameters ? { parameters } : {} }]));
+      presets.push({ id: preset.id, name: preset.name, declaration, sections: assembly.sections.map(({ name, text }) => ({ name, text })), tools: [...tools.values()] });
+    } catch (error) {
+      presets.push({ id: preset.id, name: preset.name, sections: [], tools: [], error: String(error) });
+    } finally {
+      await lease?.[Symbol.asyncDispose]();
+    }
+  }
+  const sections = new Map(presets.flatMap((preset) => preset.sections).map((section) => [section.name, section]));
+  return { presets, tools: [...all.values()].map((tool) => ({ ...tool, promptSections: (toolPromptSections[tool.name] ?? []).flatMap((name) => sections.has(name) ? [sections.get(name)] : []) })).sort((a, b) => a.name.localeCompare(b.name)) };
+}
+
+// src/host/prompt-preview.ts
+import { createScope } from "@deepseek-ai/dsh-scope";
+import { renderPrompt, renderContextSnapshot } from "@deepseek-ai/dsh-system-prompt";
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// src/master-preset.ts
+var MASTER_PRESET_ID = "studio-master";
+var MASTER_PRESET_NAME = "Studio Master";
+
+// src/provider-fields.ts
+var field = (key, type, value, minimum) => ({ key, type, ...value === void 0 ? {} : { value }, ...minimum === void 0 ? {} : { minimum } });
+var providerFields = {
+  "@deepseek-ai/dsh-compaction-basic": [field("thresholdRatio", "number", 0.8, 0), field("headroomTokens", "number", 65536, 1), field("retainRatio", "number", 0.16, 0), field("retainTokens", "number", void 0, 0), field("summarizationProvider", "string", ""), field("summarizationModel", "string", ""), field("maxTokens", "number", void 0, 1), field("compactionRetries", "number", 1, 0), field("maxOverflowRetries", "number", 1, 0), field("auto", "boolean", true)],
+  "@deepseek-ai/dsh-compaction-tool-result-pruner": [field("thresholdChars", "number", 8192, 1), field("headChars", "number", 4096, 0), field("tailChars", "number", 1024, 0)],
+  "@deepseek-ai/dsh-agent-tool-presentation": [{ key: "mode", type: "string", options: ["native", "ptc"] }],
+  "@deepseek-ai/dsh-persona": [field("prefix", "string"), field("suffix", "string", ""), field("includeRuntimeContext", "boolean", true)],
+  "@deepseek-ai/dsh-agent-instructions": [field("maxBytes", "number", 65536), field("maxSourceBytes", "number", void 0, 1), field("projectRootMarkers", "string[]"), field("instructionFileCandidates", "string[]"), field("localInstructionFileCandidates", "string[]")],
+  "@deepseek-ai/dsh-time-context": [field("timeZone", "string"), field("refreshIntervalMs", "number", void 0, 0)],
+  "@deepseek-ai/dsh-skill-filesystem": [field("providerName", "string", "filesystem"), field("includeDefaultRoots", "boolean", true), field("dshHome", "string"), field("agentsHome", "string"), field("customSkillDirs", "string[]", []), field("bundledSkillDir", "string"), field("watch", "boolean", true), field("watchUsePolling", "boolean", false), field("watchStabilityThresholdMs", "number", 200, 0), field("watchPollIntervalMs", "number", 100, 1), field("watchMaxProjects", "number", 128, 1), field("watchFollowSymlinks", "boolean", true)]
+};
+
+// src/host/composition-plan.ts
+import { load } from "js-yaml";
+import { entryListSchema } from "@deepseek-ai/cordis-plugin-include";
+
+// src/execution-defaults.ts
+function batchLimitFields(tool, parameters) {
+  if (tool !== "read_batch" || parameters.type !== "object" || !record2(parameters.properties)) return [];
+  return Object.entries(parameters.properties).flatMap(([name, schema]) => record2(schema) && schema.type === "array" && Number.isSafeInteger(schema.maxItems) && schema.maxItems > 0 && (schema.minItems === void 0 || Number.isSafeInteger(schema.minItems) && schema.minItems >= 0) ? [name] : []);
+}
+function validateBatchLimit(parameters, batch) {
+  if (!batchLimitFields(batch.tool, parameters).includes(batch.parameter)) throw new Error("Unsupported batch limit");
+  const schema = parameters.properties[batch.parameter];
+  if (!Number.isSafeInteger(batch.maxItems) || batch.maxItems < 1 || batch.maxItems > schema.maxItems || batch.maxItems < (typeof schema.minItems === "number" ? schema.minItems : 0)) throw new Error("Batch limit must tighten the published bounds");
+}
+var record2 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var names = /* @__PURE__ */ new Set(["timeoutMs", "timeout_ms"]);
+var annotations = ["description", "title", "default", "examples"];
+var bounds = ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"];
+function executionDefaultFields(parameters) {
+  if (parameters.type !== "object" || !record2(parameters.properties) || Object.keys(parameters).some((key) => !["type", "properties", "required", "additionalProperties", ...annotations].includes(key)) || parameters.required !== void 0 && (!Array.isArray(parameters.required) || parameters.required.some((key) => typeof key !== "string"))) return [];
+  return Object.entries(parameters.properties).flatMap(([name, schema]) => {
+    if (!names.has(name) || parameters.required?.includes(name) || !record2(schema) || !["number", "integer"].includes(String(schema.type)) || Object.keys(schema).some((key) => !["type", ...annotations, ...bounds, "enum", "const"].includes(key)) || bounds.some((key) => own(schema, key) && (typeof schema[key] !== "number" || !Number.isFinite(schema[key]) || key === "multipleOf" && schema[key] <= 0)) || own(schema, "const") && (typeof schema.const !== "number" || !Number.isFinite(schema.const)) || own(schema, "enum") && (!Array.isArray(schema.enum) || !schema.enum.length || schema.enum.some((value) => typeof value !== "number" || !Number.isFinite(value)))) return [];
+    return [name];
+  });
+}
+function validateExecutionDefaults(value) {
+  if (!record2(value) || Object.keys(value).some((key) => !["defaults", "batch"].includes(key)) || !record2(value.defaults)) throw new Error("Invalid execution defaults");
+  if (value.batch !== void 0 && (!record2(value.batch) || Object.keys(value.batch).some((key) => !["tool", "parameter", "maxItems"].includes(key)) || value.batch.tool !== "read_batch" || typeof value.batch.parameter !== "string" || !value.batch.parameter || ["__proto__", "prototype", "constructor"].includes(value.batch.parameter) || !Number.isSafeInteger(value.batch.maxItems) || value.batch.maxItems < 1)) throw new Error("Invalid batch limit");
+  for (const [tool, fields] of Object.entries(value.defaults)) {
+    if (!tool || ["__proto__", "prototype", "constructor"].includes(tool) || !record2(fields)) throw new Error("Invalid execution defaults");
+    for (const [field2, number] of Object.entries(fields)) if (!names.has(field2) || typeof number !== "number" || !Number.isFinite(number) || number <= 0) throw new Error(`Invalid execution default: ${tool}.${field2}`);
+  }
+}
+function validateExecutionDefault(parameters, field2, value) {
+  if (!executionDefaultFields(parameters).includes(field2)) throw new Error(`Unsupported execution default: ${field2}`);
+  const schema = parameters.properties[field2];
+  if (!Number.isFinite(value) || value <= 0 || schema.type === "integer" && !Number.isInteger(value) || typeof schema.minimum === "number" && value < schema.minimum || typeof schema.maximum === "number" && value > schema.maximum || typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum || typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum || typeof schema.multipleOf === "number" && !Number.isInteger(value / schema.multipleOf) || Array.isArray(schema.enum) && !schema.enum.includes(value) || own(schema, "const") && value !== schema.const) throw new Error(`Execution default outside schema: ${field2}`);
+}
+function applyExecutionDefaults(args, defaults) {
+  if (!record2(args)) return args;
+  return { ...Object.fromEntries(Object.entries(defaults).filter(([field2]) => !own(args, field2))), ...args };
+}
+
+// src/prompt-composition.ts
+var promptProviderModules = [
+  "@deepseek-ai/dsh-persona",
+  "@deepseek-ai/dsh-agent-instructions",
+  "@deepseek-ai/dsh-time-context",
+  "@deepseek-ai/dsh-skill-filesystem",
+  "@deepseek-ai/dsh-compaction-basic",
+  "@deepseek-ai/dsh-compaction-tool-result-pruner",
+  "@deepseek-ai/dsh-agent-tool-presentation"
+];
+function parsePreviewRequest(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid preview request");
+  const row = value;
+  const strings = (input) => Array.isArray(input) && input.every((item) => typeof item === "string");
+  if (typeof row.preset !== "string" || !strings(row.providers) || !strings(row.tools) || typeof row.prompt !== "string" || typeof row.model !== "string") throw new Error("Invalid preview request");
+  const record4 = (value2) => value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
+  if (row.persona !== void 0 && typeof row.persona !== "string") throw new Error("Invalid persona");
+  if (row.sections !== void 0 && (!record4(row.sections) || Object.values(row.sections).some((v) => typeof v !== "string"))) throw new Error("Invalid section overrides");
+  if (row.toolOverrides !== void 0 && (!record4(row.toolOverrides) || Object.values(row.toolOverrides).some((v) => !record4(v) || Object.keys(v).some((k) => !["description", "parameters"].includes(k)) || v.description !== void 0 && typeof v.description !== "string" || v.parameters !== void 0 && (!record4(v.parameters) || Object.values(v.parameters).some((p) => typeof p !== "string"))))) throw new Error("Invalid tool overrides");
+  if (row.providerConfigs !== void 0 && (!record4(row.providerConfigs) || Object.values(row.providerConfigs).some((v) => !record4(v)))) throw new Error("Invalid provider configs");
+  if (row.configOverrides !== void 0) validateConfigOverrides(row.configOverrides);
+  if (row.execution !== void 0) validateExecutionDefaults(row.execution);
+  return {
+    ...row.configOverrides !== void 0 ? { configOverrides: row.configOverrides } : {},
+    ...row.execution !== void 0 ? { execution: row.execution } : {},
+    preset: row.preset,
+    providers: [...row.providers],
+    tools: [...row.tools],
+    prompt: row.prompt,
+    model: row.model,
+    ...row.persona !== void 0 ? { persona: row.persona } : {},
+    ...row.sections !== void 0 ? { sections: row.sections } : {},
+    ...row.toolOverrides !== void 0 ? { toolOverrides: row.toolOverrides } : {},
+    ...row.providerConfigs !== void 0 ? { providerConfigs: row.providerConfigs } : {}
+  };
+}
+function promptProviders(rows) {
+  const found = [];
+  for (const row of rows) {
+    if (row.disabled === true) continue;
+    if (row.group && Array.isArray(row.config)) found.push(...promptProviders(row.config));
+    else if (promptProviderModules.includes(row.name)) {
+      const config = row.config ?? {};
+      found.push({ name: row.name, description: row.name.replace("@deepseek-ai/dsh-", ""), fields: (providerFields[row.name] ?? []).map((field2) => ({ ...field2, ...Object.hasOwn(config, field2.key) ? { value: config[field2.key] } : {} })) });
+    }
+  }
+  return [...new Map(found.map((item) => [item.name, item])).values()];
+}
+function selectPromptProviders(rows, selected) {
+  const available = new Set(promptProviders(rows).map((item) => item.name));
+  if (selected.some((name) => !available.has(name))) throw new Error("Unknown prompt provider selection");
+  const visit = (entries) => entries.flatMap((row) => {
+    if (row.name === "@deepseek-ai/dsh-command-compact" && !selected.includes("@deepseek-ai/dsh-compaction-basic")) return [];
+    if (promptProviderModules.includes(row.name) && !selected.includes(row.name)) return [];
+    return [{ ...row, ...row.group && Array.isArray(row.config) ? { config: visit(row.config) } : {} }];
+  });
+  return visit(rows);
+}
+
+// src/host/composition-plan.ts
+function parseComposition(content) {
+  const rows = load(content, { schema: entryListSchema });
+  if (!Array.isArray(rows)) throw new Error("Preset declaration must be a plugin list");
+  return rows;
+}
+function findProviders(rows) {
+  return rows.flatMap((row) => row.disabled === true ? [] : row.group && Array.isArray(row.config) ? findProviders(row.config) : promptProviderModules.includes(row.name) ? [row] : []);
+}
+async function compositionPlan(ctx, input) {
+  const request = parsePreviewRequest(input);
+  const base = request.preset === MASTER_PRESET_ID ? MASTER_PRESET_ID : "minimal";
+  if (request.configOverrides && base !== MASTER_PRESET_ID) throw new Error("Config overrides require Studio Master");
+  const minimal = applyConfigOverrides(parseComposition((await ctx.agentPresets.readDocument(base)).content), request.configOverrides ?? {});
+  const available = new Map(findProviders(minimal).map((row) => [row.name, row]));
+  const presets = await ctx.agentPresets.list();
+  for (const preset of presets) {
+    if (base === MASTER_PRESET_ID || !["minimal", "standard", "ptc", "cordis"].includes(preset.id)) continue;
+    try {
+      for (const row of findProviders(parseComposition((await ctx.agentPresets.readDocument(preset.id)).content))) {
+        if (!available.has(row.name)) available.set(row.name, row);
+      }
+    } catch {
+    }
+  }
+  const plugins = [...new Set(request.providers)].map((name, index) => {
+    const row = available.get(name);
+    if (!row) throw new Error(`Unavailable prompt provider: ${name}`);
+    const config = { ...row.config ?? {} };
+    const overrides = request.providerConfigs?.[name];
+    if (overrides) {
+      for (const [key, value] of Object.entries(overrides)) {
+        const field2 = providerFields[name]?.find((field3) => field3.key === key);
+        const valid = field2 && (field2.type === "string[]" ? Array.isArray(value) && value.every((item) => typeof item === "string") : typeof value === field2.type);
+        if (!valid || field2?.options && !field2.options.includes(String(value)) || typeof value === "number" && (!Number.isFinite(value) || field2?.minimum !== void 0 && value < field2.minimum)) throw new Error(`Unsupported provider setting: ${name}.${key}`);
+        if (key === "timeZone" && typeof value === "string") new Intl.DateTimeFormat("en", { timeZone: value }).format();
+        config[key] = value;
+      }
+    }
+    if (name === "@deepseek-ai/dsh-persona") {
+      config.complete = false;
+      if (request.persona !== void 0) config.prefix = request.persona;
+    }
+    if (name === "@deepseek-ai/dsh-compaction-basic") {
+      if (overrides?.retainTokens !== void 0 && overrides.retainRatio === void 0) delete config.retainRatio;
+      if (overrides?.retainRatio !== void 0 && overrides.retainTokens === void 0) delete config.retainTokens;
+    }
+    return { ...row, id: `studio-provider-${index}`, config };
+  });
+  if (request.persona !== void 0 && !request.providers.includes("@deepseek-ai/dsh-persona")) throw new Error("Select persona before editing its prefix");
+  for (const name of Object.keys(request.providerConfigs ?? {})) if (!request.providers.includes(name)) throw new Error(`Unselected provider override: ${name}`);
+  const globalNames = new Set(ctx.tools.schemas().map((tool) => tool.name));
+  const missing = request.tools.filter((name) => !globalNames.has(name));
+  if (missing.length || base === MASTER_PRESET_ID) {
+    let source;
+    const candidates = base === MASTER_PRESET_ID ? [MASTER_PRESET_ID] : ["minimal", ...presets.map((p) => p.id).filter((id) => id !== "minimal" && !id.startsWith("studio-"))];
+    for (const id of candidates) {
+      let lease;
+      try {
+        lease = await ctx.agentPresets.acquireScope(id);
+        const names2 = new Set(ctx.tools.schemas(lease.key).map((tool) => tool.name));
+        if (missing.every((name) => names2.has(name))) {
+          source = id === base ? minimal : parseComposition((await ctx.agentPresets.readDocument(id)).content);
+          break;
+        }
+      } catch {
+      } finally {
+        await lease?.[Symbol.asyncDispose]();
+      }
+    }
+    if (!source) throw new Error(`No compatible installed tool composition supplies: ${missing.join(", ")}. Tools from incompatible source scopes cannot be combined safely.`);
+    plugins.push(...selectPromptProviders(source, []));
+  }
+  const compaction = plugins.filter((row) => ["@deepseek-ai/dsh-compaction-basic", "@deepseek-ai/dsh-compaction-tool-result-pruner"].includes(row.name));
+  const isolated = plugins.filter((row) => !compaction.includes(row));
+  if (compaction.length) isolated.push({ id: "studio-compaction", name: "cordis:group", group: true, isolate: { compaction: true, toolResultPruner: true }, config: compaction });
+  return { request, plugins: isolated };
+}
+
+// src/host/preset-policy.ts
+import { scopeOf } from "@deepseek-ai/dsh-scope";
+var POLICY_SECTION_ORDERS = Object.freeze({
+  "tool:jobs": "TOOL_JOBS",
+  "tool:bash": "TOOL_BASH",
+  "tool:pwsh": "TOOL_PWSH",
+  "tool:read": "TOOL_READ",
+  "tool:write": "TOOL_WRITE",
+  "tool:edit": "TOOL_EDIT",
+  "tool:glob": "TOOL_GLOB",
+  "tool:grep": "TOOL_GREP",
+  "tool:web_fetch": "TOOL_WEB_FETCH",
+  "tool:web_search": "TOOL_WEB_SEARCH",
+  "tool:goal": "TOOL_GOAL"
+});
+var own2 = (object3, key) => Object.prototype.hasOwnProperty.call(object3, key);
+var record3 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function validatePolicy(config) {
+  if (!record3(config) || !Array.isArray(config.tools) || config.tools.some((name) => typeof name !== "string" || !name) || new Set(config.tools).size !== config.tools.length || !record3(config.toolOverrides) || !record3(config.sections) || typeof config.prompt !== "string") throw new Error("Invalid Studio policy");
+  if (config.execution !== void 0) {
+    validateExecutionDefaults(config.execution);
+    for (const name of Object.keys(config.execution.defaults)) if (!config.tools.includes(name)) throw new Error(`Execution default requires selected tool: ${name}`);
+    if (config.execution.batch && !config.tools.includes(config.execution.batch.tool)) throw new Error("Batch limit requires selected tool");
+  }
+  for (const [name, override] of Object.entries(config.toolOverrides)) {
+    if (!config.tools.includes(name)) throw new Error(`Override requires selected tool: ${name}`);
+    if (!record3(override) || Object.keys(override).some((key) => !["description", "parameters"].includes(key)) || override.description !== void 0 && typeof override.description !== "string" || override.parameters !== void 0 && (!record3(override.parameters) || Object.values(override.parameters).some((value) => typeof value !== "string"))) throw new Error(`Invalid override: ${name}`);
+  }
+  for (const [name, text] of Object.entries(config.sections)) {
+    if (!own2(POLICY_SECTION_ORDERS, name) || typeof text !== "string") throw new Error(`Unsupported policy section: ${name}`);
+  }
+}
+function patchParameter(parameters, path, description) {
+  const segments = path.split(".");
+  let node = parameters;
+  for (const segment of segments) {
+    if (!segment || ["__proto__", "prototype", "constructor"].includes(segment) || !record3(node.properties) || !own2(node.properties, segment) || !record3(node.properties[segment])) throw new Error(`Unknown parameter path: ${path}`);
+    node = node.properties[segment];
+  }
+  node.description = description;
+}
+function installPolicy(ctx, scopeKey, config) {
+  validatePolicy(config);
+  if (scopeOf(ctx) !== scopeKey) throw new Error("Studio policy requires its owning scoped context");
+  const selected = new Set(config.tools);
+  const definitions = config.tools.map((name) => {
+    const definition = ctx.tools.get(name, scopeKey);
+    if (!definition) throw new Error(`Unavailable selected tool: ${name}`);
+    const override = config.toolOverrides[name];
+    const defaults = config.execution?.defaults[name];
+    const batch = config.execution?.batch?.tool === name ? config.execution.batch : void 0;
+    if (!override && !defaults && !batch) return void 0;
+    const parameters = structuredClone(definition.parameters);
+    for (const [path, description] of Object.entries(override?.parameters ?? {})) patchParameter(parameters, path, description);
+    for (const [field2, value] of Object.entries(defaults ?? {})) {
+      validateExecutionDefault(parameters, field2, value);
+      parameters.properties[field2].default = value;
+    }
+    if (batch) {
+      validateBatchLimit(parameters, batch);
+      parameters.properties[batch.parameter].maxItems = batch.maxItems;
+    }
+    const stableDefaults = { ...defaults };
+    const stableBatch = batch && { ...batch };
+    return {
+      ...definition,
+      parameters,
+      ...override?.description === void 0 ? {} : { description: override.description },
+      ...defaults || batch ? { execute(args, exec) {
+        const effective = applyExecutionDefaults(args, stableDefaults);
+        if (stableBatch && record3(effective) && Array.isArray(effective[stableBatch.parameter]) && effective[stableBatch.parameter].length > stableBatch.maxItems) throw new Error(`Studio batch limit exceeded: ${stableBatch.maxItems}`);
+        return definition.execute.call(definition, effective, exec);
+      } } : {}
+    };
+  }).filter((definition) => definition !== void 0);
+  const disposers = [];
+  const dispose = () => {
+    for (const release of disposers.splice(0).reverse()) release();
+  };
+  try {
+    disposers.push(ctx.tools.restrict({ allow: config.tools }));
+    const excess = ctx.tools.schemas(scopeKey).filter((tool) => !selected.has(tool.name));
+    if (excess.length) throw new Error(`Unselected scoped tools must be removed from preset plugins: ${excess.map((tool) => tool.name).join(", ")}`);
+    disposers.push(ctx.tools.guard((execution) => selected.has(execution.name) ? void 0 : "Tool excluded by Studio preset policy"));
+    for (const definition of definitions) disposers.push(ctx.tools.register(definition));
+    for (const [name, text] of Object.entries(config.sections)) disposers.push(ctx.systemPrompt.section({ name, order: ctx.systemPrompt.getSectionOrder(POLICY_SECTION_ORDERS[name]), text, interpolate: false }));
+    disposers.push(ctx.systemPrompt.section({ name: "studio:additional", order: Number.MAX_SAFE_INTEGER, text: config.prompt, interpolate: false }));
+    return dispose;
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+}
+
+// src/host/prompt-preview.ts
+async function assemblePreview(ctx, input) {
+  const { request, plugins } = await compositionPlan(ctx, { ...input, tools: delegationTools(input.tools) });
+  const id = `studio-preview-${randomUUID2()}`;
+  const unregister = await ctx.agentPresets.register({ id, plugins });
+  try {
+    if (ctx.agentPresets.resolve) {
+      const resolved = await ctx.agentPresets.resolve(id);
+      if (resolved.broken) throw new Error(resolved.broken);
+    }
+    const lease = await ctx.agentPresets.acquireScope(id);
+    try {
+      const key = {};
+      const child = createScope(ctx, key, { parent: lease.key });
+      try {
+        installPolicy(child.ctx, key, { tools: request.tools, toolOverrides: request.toolOverrides ?? {}, sections: request.sections ?? {}, prompt: request.prompt, ...request.execution ? { execution: request.execution } : {} });
+        child.ctx.systemPrompt.variable("cwd", () => process.cwd());
+        if (request.model.trim()) child.ctx.systemPrompt.variable("model", () => request.model.trim());
+        const assembly = await ctx.systemPrompt.assemble({ scope: key });
+        const actual = assembly.tools.map((tool) => tool.name);
+        if (actual.some((name) => !request.tools.includes(name)) || request.tools.some((name) => !actual.includes(name))) throw new Error("Assembler tool output differs from the selected tools");
+        return {
+          prompt: renderPrompt(assembly),
+          sections: assembly.sections.map((section) => ({ name: section.name, text: renderPrompt({ ...assembly, sections: [section] }) })).filter((section) => section.text),
+          context: renderContextSnapshot(assembly),
+          tools: assembly.tools
+        };
+      } finally {
+        await child.dispose();
+      }
+    } finally {
+      await lease[Symbol.asyncDispose]();
+    }
+  } finally {
+    await unregister();
+  }
+}
+
+// src/execution-capabilities.ts
+function executionCapabilities(tools) {
+  const waits = [];
+  let batch;
+  for (const tool of tools) {
+    const properties = tool.parameters?.properties;
+    for (const [parameter, schema] of Object.entries(properties ?? {})) {
+      if (["timeoutMs", "timeout_ms"].includes(parameter) && ["number", "integer"].includes(String(schema.type))) {
+        waits.push({ tool: tool.name, parameter, supported: executionDefaultFields(tool.parameters ?? {}).includes(parameter), ...typeof schema.minimum === "number" ? { minimum: schema.minimum } : {}, ...typeof schema.maximum === "number" ? { maximum: schema.maximum } : {}, ...typeof schema.default === "number" ? { defaultValue: schema.default } : {} });
+      }
+      if (batchLimitFields(tool.name, tool.parameters ?? {}).includes(parameter)) batch = { tool: tool.name, parameter, ...typeof schema.maxItems === "number" ? { maxItems: schema.maxItems } : {} };
+    }
+  }
+  return { waits, ...batch ? { batch } : {}, spill: { supported: false, reason: "policy-integration-unverified" } };
+}
+
+// src/host/preset-store.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2, rename as rename2 } from "node:fs/promises";
+import { dirname as dirname2, join } from "node:path";
+import { dump } from "js-yaml";
+import { entryListSchema as entryListSchema2 } from "@deepseek-ai/cordis-plugin-include";
+
+// src/role-settings.ts
+var object2 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function parseRoles(input) {
+  if (!Array.isArray(input) || input.length > 50) throw new Error("Studio agents must be an array of at most 50 roles");
+  const seen = /* @__PURE__ */ new Set();
+  return input.map((value) => {
+    if (!object2(value)) throw new Error("Invalid Studio role");
+    const text = (key, fallback, max) => {
+      const v = value[key] ?? fallback;
+      if (typeof v !== "string" || v.length > max) throw new Error(`Invalid role ${key}`);
+      return key === "persona" ? v : v.trim();
+    };
+    const name = text("name", "", 120);
+    const role = text("role", name, 120);
+    const model = text("model", "inherit", 512);
+    const reasoning = text("reasoning", "inherit", 120);
+    const spawn = text("spawn", "fresh", 10);
+    const persona = text("persona", "", 32e3);
+    if (!name || !role || seen.has(role)) throw new Error("Role names and unique role identifiers are required");
+    if (model !== "inherit" && !/^[^\s/]+\/\S+$/.test(model)) throw new Error("Role model must be inherit or provider/model");
+    if (!/^[a-zA-Z0-9_-]+$/.test(reasoning)) throw new Error("Role reasoning must be inherit or an effort identifier");
+    if (spawn !== "fresh" && spawn !== "fork") throw new Error("Role spawn must be fresh or fork");
+    seen.add(role);
+    return { name, role, model, reasoning, spawn, persona, ..."overrides" in value ? { overrides: structuredClone(value.overrides) } : {} };
+  });
+}
+function executableRoles(roles) {
+  return roles.map(({ name, role, model, reasoning, spawn, persona }) => ({ name, role, model, reasoning, spawn, persona }));
+}
+
+// src/host/role-validation.ts
+import { ReasoningEffortId } from "@deepseek-ai/dsh-llm";
+async function validateRoleModel(llm, role, signal) {
+  signal?.throwIfAborted();
+  if (role.model === "inherit") return;
+  if (!llm) throw new Error("Studio role model validation unavailable: LLM service is not mounted.");
+  const slash = role.model.indexOf("/");
+  const provider = role.model.slice(0, slash);
+  const model = role.model.slice(slash + 1);
+  if (!llm.listProviders().some((item) => item.id === provider)) {
+    throw new Error(`Studio role "${role.role}": provider "${provider}" is not registered. Select an available model in Studio, save and reapply the preset.`);
+  }
+  try {
+    await llm.resolveCallConfig({
+      provider,
+      model,
+      ...role.reasoning === "inherit" ? {} : { reasoningEffort: ReasoningEffortId(role.reasoning) }
+    }, signal);
+  } catch {
+    signal?.throwIfAborted();
+    throw new Error(`Studio role "${role.role}": could not validate model "${role.model}" and reasoning settings. Check provider availability and model settings, then retry. No child was started.`);
+  }
+  signal?.throwIfAborted();
+}
+
+// src/host/preset-store.ts
+var owned = (id) => id === OPTIMIZED_PRESET_ID || /^studio-user-[a-f0-9-]{36}$/.test(id);
+var warning = "Work convenience settings are saved but not applied yet. Legacy role overrides are stored only; roles apply only their supported settings.";
+function migrateLegacyNames(row) {
+  const request = row.request;
+  if (request.toolOverrides) {
+    const next = renameLegacyRoleKey(request.toolOverrides);
+    if (next) request.toolOverrides = next;
+  }
+  if (request.execution?.defaults) {
+    const next = renameLegacyRoleKey(request.execution.defaults);
+    if (next) request.execution.defaults = next;
+  }
+  if (!row.applied || !row.applied.plugins.includes("studio_role") && !row.applied.plugins.includes(LEGACY_PACKAGE_NAME)) return;
+  const visit = (entries) => entries.map((entry) => {
+    const name = currentPluginName(entry.name);
+    const config = entry.group && Array.isArray(entry.config) ? visit(entry.config) : name === POLICY_PLUGIN && entry.config && typeof entry.config === "object" ? migratePolicyConfig(entry.config) : entry.config;
+    return { ...entry, name, ...config === void 0 ? {} : { config } };
+  });
+  row.applied = { ...row.applied, plugins: dump(visit(parseComposition(row.applied.plugins)), { schema: entryListSchema2, noRefs: true }) };
+}
+function studioStorePath(env = process.env, profile) {
+  const directory = profile?.dir ?? env.DSH_PROFILE_DIR;
+  if (!directory) throw new Error("Studio preset persistence requires a profile");
+  return join(directory, "studio-data", "presets.json");
+}
+var PresetStore = class {
+  constructor(ctx, file) {
+    this.ctx = ctx;
+    this.file = file;
+  }
+  rows = [];
+  disposers = /* @__PURE__ */ new Map();
+  ready;
+  tail = Promise.resolve();
+  initialize() {
+    return this.ready ??= (async () => {
+      try {
+        const value = JSON.parse(await readFile2(this.file, "utf8"));
+        if (value.version !== 1 || !Array.isArray(value.presets)) throw new Error("Unsupported Studio preset store");
+        this.rows = value.presets;
+        for (const row of this.rows) {
+          if (!owned(row.id)) throw new Error("Invalid Studio preset ownership");
+          parsePreviewRequest(row.request);
+          migrateLegacyNames(row);
+        }
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      for (const row of this.rows) if (row.applied) {
+        try {
+          await this.mount(row.id, row.applied);
+        } catch (error) {
+          row.applyWarning = `Restore failed: ${String(error)}`;
+          row.status = "modified";
+        }
+      }
+    })();
+  }
+  async mount(id, definition) {
+    const dispose = await this.ctx.agentPresets.register({ id, name: definition.name, description: definition.description, plugins: parseComposition(definition.plugins) });
+    try {
+      const preset = await this.ctx.agentPresets.resolve(id);
+      if (preset.broken) throw new Error(preset.broken);
+      this.disposers.set(id, dispose);
+    } catch (error) {
+      await dispose();
+      throw error;
+    }
+  }
+  async persist(rows) {
+    await mkdir2(dirname2(this.file), { recursive: true, mode: 448 });
+    const temp = `${this.file}.tmp`;
+    await writeFile2(temp, JSON.stringify({ version: 1, presets: rows }, null, 2), { mode: 384 });
+    await rename2(temp, this.file);
+    this.rows = rows;
+  }
+  serial(action) {
+    const result = this.tail.then(async () => {
+      await this.initialize();
+      return action();
+    });
+    this.tail = result.catch(() => {
+    });
+    return result;
+  }
+  public(row) {
+    const { applied, ...value } = row;
+    return structuredClone({ ...value, ...row.id === OPTIMIZED_PRESET_ID ? { template: true, nonDeletable: true } : {} });
+  }
+  /** Seed once. Later startups retain user edits and explicit unapplied state. */
+  ensureOptimized(tools, plugins) {
+    return this.serial(async () => {
+      const existing = this.rows.find((row2) => row2.id === OPTIMIZED_PRESET_ID);
+      if (existing) return this.public(existing);
+      const template = optimizedTemplate(tools);
+      const request = template.request;
+      const delegates = request.tools.includes(ROLE_TOOL);
+      const base = applyConfigOverrides(plugins, request.configOverrides ?? {});
+      const applied = { name: template.name, description: template.description, plugins: dump([...delegates ? [...withoutDelegationPlugins(base), { id: "studio-roles", name: ROLE_PLUGIN, config: { roles: [] } }] : base, { id: "studio-optimized-policy", name: POLICY_PLUGIN, config: { tools: request.tools, toolOverrides: request.toolOverrides, sections: {}, prompt: request.prompt, execution: request.execution } }], { schema: entryListSchema2, noRefs: true }) };
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const row = { id: template.id, name: template.name, description: template.description, request: template.request, conveniences: {}, agents: [], updatedAt: now, appliedAt: now, status: "applied", applied, ...template.applyWarning ? { applyWarning: template.applyWarning } : {} };
+      await this.mount(row.id, applied);
+      try {
+        await this.persist([...this.rows, row]);
+      } catch (error) {
+        await this.disposers.get(row.id)?.();
+        this.disposers.delete(row.id);
+        throw error;
+      }
+      return this.public(row);
+    });
+  }
+  list() {
+    return this.serial(async () => this.rows.map((row) => this.public(row)));
+  }
+  save(payload) {
+    return this.serial(async () => {
+      const value = JSON.parse(payload);
+      if (!value || typeof value.name !== "string" || !value.name.trim() || value.name.length > 120 || typeof value.description !== "string") throw new Error("Invalid preset name or description");
+      const old = value.id ? this.find(value.id) : void 0;
+      const row = {
+        ...old,
+        id: old?.id ?? `studio-user-${randomUUID3()}`,
+        name: value.name.trim(),
+        description: value.description,
+        request: parsePreviewRequest(value.request),
+        conveniences: value.conveniences ?? {},
+        agents: parseRoles(value.agents ?? old?.agents ?? []).map((role) => {
+          const prior = Array.isArray(old?.agents) ? old.agents.find((item) => item.role === role.role || item.name === role.name) : void 0;
+          return prior && "overrides" in prior && !("overrides" in role) ? { ...role, overrides: prior.overrides } : role;
+        }),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: old?.applied ? "modified" : "draft"
+      };
+      await this.persist([...this.rows.filter((item) => item.id !== row.id), row]);
+      return this.public(row);
+    });
+  }
+  find(id) {
+    if (!owned(id)) throw new Error("Only Studio-owned presets may be managed");
+    const row = this.rows.find((row2) => row2.id === id);
+    if (!row) throw new Error("Studio preset not found");
+    return row;
+  }
+  apply(id) {
+    return this.serial(async () => {
+      const old = this.find(id);
+      const roles = executableRoles(parseRoles(old.agents));
+      const tools = delegationTools(old.request.tools, roles.length > 0);
+      const { request, plugins } = await compositionPlan(this.ctx, { ...old.request, tools: tools.filter((name) => name !== ROLE_TOOL) });
+      for (const role of roles) await validateRoleModel(this.ctx.get("llm"), role);
+      const delegates = tools.includes(ROLE_TOOL);
+      const keep = (entries) => Object.fromEntries(Object.entries(entries).filter(([name]) => tools.includes(name)));
+      const rolePlugins = delegates ? [{ id: "studio-roles", name: ROLE_PLUGIN, config: { roles } }] : [];
+      const execution = request.execution && {
+        ...request.execution,
+        defaults: keep(request.execution.defaults),
+        ...request.execution.batch && !tools.includes(request.execution.batch.tool) ? { batch: void 0 } : {}
+      };
+      const applied = { name: old.name, description: old.description, plugins: dump([...withoutDelegationPlugins(plugins), ...rolePlugins, { id: "studio-policy", name: POLICY_PLUGIN, config: { tools: [...new Set(tools)], toolOverrides: keep(request.toolOverrides ?? {}), sections: request.sections ?? {}, prompt: request.prompt, ...execution ? { execution } : {} } }], { schema: entryListSchema2, noRefs: true }) };
+      await this.disposers.get(id)?.();
+      this.disposers.delete(id);
+      try {
+        await this.mount(id, applied);
+        const hasLegacySettings = old.conveniences != null && Object.keys(Object(old.conveniences)).length > 0 || Array.isArray(old.agents) && old.agents.some((role) => role && Object.hasOwn(role, "overrides"));
+        const row = { ...old, applied, appliedAt: (/* @__PURE__ */ new Date()).toISOString(), status: "applied" };
+        if (hasLegacySettings) row.applyWarning = warning;
+        else delete row.applyWarning;
+        await this.persist(this.rows.map((item) => item.id === id ? row : item));
+        return this.public(row);
+      } catch (error) {
+        await this.disposers.get(id)?.();
+        this.disposers.delete(id);
+        if (old.applied) await this.mount(id, old.applied);
+        throw error;
+      }
+    });
+  }
+  unapply(id) {
+    return this.serial(async () => {
+      const old = this.find(id);
+      await this.disposers.get(id)?.();
+      this.disposers.delete(id);
+      const { applied, appliedAt, applyWarning, ...draft } = old;
+      const row = { ...draft, status: "draft" };
+      try {
+        await this.persist(this.rows.map((item) => item.id === id ? row : item));
+      } catch (error) {
+        if (applied) await this.mount(id, applied);
+        throw error;
+      }
+      return this.public(row);
+    });
+  }
+  delete(id) {
+    return this.serial(async () => {
+      if (id === OPTIMIZED_PRESET_ID) throw new Error("Optimized is a non-deletable built-in preset");
+      const old = this.find(id);
+      await this.disposers.get(id)?.();
+      this.disposers.delete(id);
+      try {
+        await this.persist(this.rows.filter((row) => row.id !== id));
+      } catch (error) {
+        if (old.applied) await this.mount(id, old.applied);
+        throw error;
+      }
+      return { id };
+    });
+  }
+  async dispose() {
+    await this.tail;
+    for (const dispose of this.disposers.values()) await dispose();
+    this.disposers.clear();
+  }
+};
+
+// src/host/shell.ts
+var _preview_dec, _saveExtensions_dec, _readExtensions_dec, _read_dec, _deletePreset_dec, _roleModels_dec, _unapplyPreset_dec, _applyPreset_dec, _savePreset_dec, _listPresets_dec, _a, _init;
+var StudioCatalog = class extends (_a = TypertRemoteService, _listPresets_dec = [Remote], _savePreset_dec = [Remote], _applyPreset_dec = [Remote], _unapplyPreset_dec = [Remote], _roleModels_dec = [Remote], _deletePreset_dec = [Remote], _read_dec = [Remote], _readExtensions_dec = [Remote], _saveExtensions_dec = [Remote], _preview_dec = [Remote], _a) {
+  constructor(ctx) {
+    super(ctx, "studioCatalog");
+    __runInitializers(_init, 5, this);
+    __publicField(this, "store");
+    __publicField(this, "snapshot");
+    __publicField(this, "disposeMaster");
+    __publicField(this, "stopped", false);
+    __publicField(this, "extensions");
+    __publicField(this, "changes", Promise.resolve());
+    const storePath = studioStorePath(process.env, ctx.get("profileContext"));
+    this.extensions = new MasterExtensions(join2(dirname3(storePath), "master-extensions.json"));
+    this.store = new PresetStore(ctx, storePath);
+    this.snapshot = new Promise((resolve2) => {
+      setImmediate(resolve2);
+    }).then(() => this.capture());
+    void this.snapshot.catch(() => void 0);
+    ctx.effect(() => async () => {
+      this.stopped = true;
+      await this.snapshot.catch(() => {
+      });
+      await this.disposeMaster?.();
+    });
+    ctx.effect(async () => {
+      await this.store.initialize();
+      return () => this.store.dispose();
+    });
+  }
+  async listPresets() {
+    const catalog = await this.snapshot;
+    return [{ id: MASTER_PRESET_ID, name: MASTER_PRESET_NAME, description: "Studio Master \xB7 read-only", readOnly: true, status: "applied", agents: [], request: { preset: MASTER_PRESET_ID, providers: [], tools: catalog.tools.map((tool) => tool.name), prompt: "", model: "testLLM" } }, ...(await this.store.list()).sort((a, b) => Number(b.id === OPTIMIZED_PRESET_ID) - Number(a.id === OPTIMIZED_PRESET_ID))];
+  }
+  async savePreset(payload) {
+    return this.store.save(payload);
+  }
+  async applyPreset(id) {
+    await this.snapshot;
+    return this.store.apply(id);
+  }
+  async unapplyPreset(id) {
+    return this.store.unapply(id);
+  }
+  async roleModels() {
+    const service = this.ctx.get("sessionController");
+    if (!service) throw new Error("Model catalog API unavailable");
+    return service.modelCatalog();
+  }
+  async deletePreset(id) {
+    return this.store.delete(id);
+  }
+  async read() {
+    return structuredClone(await this.snapshot);
+  }
+  async readExtensions() {
+    await this.snapshot;
+    return this.extensions.read();
+  }
+  async saveExtensions(payload) {
+    const rows = validateExtensions(JSON.parse(payload));
+    const operation = this.changes.catch(() => {
+    }).then(async () => {
+      await this.snapshot;
+      const previous = await this.extensions.read();
+      const probe = `studio-probe-${randomUUID4()}`;
+      const dispose = await this.ctx.agentPresets.register({ id: probe, plugins: this.composition(rows) });
+      try {
+        const resolved = await this.ctx.agentPresets.resolve(probe);
+        if (resolved.broken) throw new Error(resolved.broken);
+      } finally {
+        await dispose();
+      }
+      const update = (async () => {
+        await this.disposeMaster?.();
+        try {
+          const catalog = await this.capture(rows);
+          await this.extensions.save(rows);
+          return catalog;
+        } catch (error) {
+          await this.disposeMaster?.();
+          const restored = await this.capture(previous);
+          this.snapshot = Promise.resolve(restored);
+          throw error;
+        }
+      })();
+      this.snapshot = update;
+      try {
+        return await update;
+      } catch (error) {
+        throw error;
+      }
+    });
+    this.changes = operation;
+    return operation;
+  }
+  composition(rows) {
+    return [...masterComposition(), ...rows.length ? [{ id: "studio-added", name: "cordis:group", group: true, config: rows }] : []];
+  }
+  async capture(extra) {
+    const project = await createConfigProjector();
+    await this.ctx.loader.await();
+    const composition = this.composition(extra ?? await this.extensions.read());
+    const plugins = [];
+    for (const { id, row } of configEntries(composition)) {
+      const item = { id, name: row.name, ...id.startsWith("studio-added/") ? {} : { config: structuredClone(row.config ?? {}) } };
+      try {
+        const module = this.ctx.loader.unwrapExports(await this.ctx.loader.import(row.name));
+        if (module?.Config) {
+          if (!isNativeConfigSchema(module.Config)) throw new Error("Unsupported Config schema");
+          const result = project(module.Config, "config");
+          item.schema = JSON.parse(JSON.stringify({ $schema: "https://json-schema.org/draft/2020-12/schema", ...result.schema, $defs: { ...result.definitions, loaderExpression: LOADER_EXPRESSION_SCHEMA } }));
+        }
+      } catch (error) {
+        item.error = String(error);
+      }
+      plugins.push(item);
+    }
+    if (this.stopped) throw new Error("Studio stopped during catalog initialization");
+    this.disposeMaster = await this.ctx.agentPresets.register({ id: MASTER_PRESET_ID, name: MASTER_PRESET_NAME, description: "Studio-managed read-only explicit composition", plugins: composition });
+    const master = await this.ctx.agentPresets.resolve(MASTER_PRESET_ID);
+    if (master.broken) throw new Error(`Studio Master: ${master.broken}`);
+    const registry = this.ctx.get("agentPresets");
+    const catalog = await readPresetCatalog({
+      agentPresets: { list: async () => [{ id: MASTER_PRESET_ID, name: MASTER_PRESET_NAME }, ...(await registry.list()).filter((p) => BUILTIN_TOOL_PRESETS.includes(p.id))], readDocument: (id) => registry.readDocument(id), acquireScope: (id) => registry.acquireScope(id) },
+      systemPrompt: this.ctx.get("systemPrompt"),
+      tools: this.ctx.get("tools")
+    });
+    if (catalog.presets[0]?.error) throw new Error(catalog.presets[0].error);
+    for (const preset of catalog.presets) {
+      if (preset.declaration) preset.promptProviders = promptProviders(parseComposition(preset.declaration));
+    }
+    const baseline = catalog.presets.find((p) => p.id === MASTER_PRESET_ID);
+    await this.store.ensureOptimized(baseline.tools.map((t) => t.name), composition);
+    catalog.plugins = plugins;
+    catalog.execution = executionCapabilities(catalog.tools);
+    return catalog;
+  }
+  async preview(request) {
+    await this.snapshot;
+    return assemblePreview(this.ctx, request);
+  }
+};
+_init = __decoratorStart(_a);
+__decorateElement(_init, 1, "listPresets", _listPresets_dec, StudioCatalog);
+__decorateElement(_init, 1, "savePreset", _savePreset_dec, StudioCatalog);
+__decorateElement(_init, 1, "applyPreset", _applyPreset_dec, StudioCatalog);
+__decorateElement(_init, 1, "unapplyPreset", _unapplyPreset_dec, StudioCatalog);
+__decorateElement(_init, 1, "roleModels", _roleModels_dec, StudioCatalog);
+__decorateElement(_init, 1, "deletePreset", _deletePreset_dec, StudioCatalog);
+__decorateElement(_init, 1, "read", _read_dec, StudioCatalog);
+__decorateElement(_init, 1, "readExtensions", _readExtensions_dec, StudioCatalog);
+__decorateElement(_init, 1, "saveExtensions", _saveExtensions_dec, StudioCatalog);
+__decorateElement(_init, 1, "preview", _preview_dec, StudioCatalog);
+__decoratorMetadata(_init, StudioCatalog);
+__publicField(StudioCatalog, "inject", ["agentPresets", "systemPrompt", "tools", "loader"]);
+export {
+  StudioCatalog as default
+};