@integrity-labs/agt-cli 0.28.889 → 0.28.891

package/dist/mcp/index.js

@@ -29779,14 +29779,38 @@ var FLAG_REGISTRY = [
   },
   {
     key: "agent-unified-screen",
-    description: 'Unified agent screen redesign (ENG-8478 epic / ENG-8480). When ON, the webapp renders the new single-screen "viewing is editing" agent surface (stripped-back hero, working agent switcher, inline-editable profile, embedded operational panels + a live direct-chat drawer) in place of the separate agent view/edit pages; when OFF, the current view/edit pages are unchanged. Additive UI gate \u2014 no data-model change: each panel reads the same existing endpoints the current pages use. Composes independently with app-top-nav-shell (the two flags are reconciled in ENG-8488). Ships dark.',
+    description: 'Unified agent screen redesign (ENG-8478 epic / ENG-8480). When ON, the webapp renders the new single-screen "viewing is editing" agent surface (stripped-back hero, working agent switcher, inline-editable profile, embedded operational panels + a live direct-chat drawer) in place of the separate agent view/edit pages; when OFF, the current view/edit pages are unchanged. Additive UI gate \u2014 no data-model change: each panel reads the same existing endpoints the current pages use. Composes independently with app-top-nav-shell (the two flags are reconciled in ENG-8488). NO LONGER DARK: ENG-9832 cutover step 1 flipped the default to true, so an org with no override now gets the unified screen. The key survives only until cutover step 2 deletes it \u2014 which is blocked on ENG-8547 and ENG-8559, because the flag-off branch is still the only home for the /edit tabs.',
     flagType: "boolean",
-    // Declared safe value is `false` = the current view/edit pages. A flag-DB read
-    // error must fall back to what ships today, never a half-built redesign.
-    defaultValue: false,
-    // Read CLIENT-SIDE by the agent screen ("use client") via usePublicBooleanFlag,
-    // so the key must be in the browser-exposed public map. Additive viewer gate,
-    // resolved within the active-org cookie's scope — not sensitive.
+    // ENG-9832 (cutover step 1): flipped `false` -> `true`. The comment this
+    // replaces called `false` the safe direction — "the current view/edit
+    // pages", never "a half-built redesign". That was true while the redesign
+    // was half built. It has been the shipped surface for the pilot orgs since
+    // ENG-8481, so `false` now points at the pages being retired, not at safety.
+    // The old rationale is recorded rather than deleted because it was correct
+    // under a premise that has since expired.
+    //
+    // MIND THE SPLIT. This value is consulted by the API evaluator when it
+    // builds the `GET /flags` map for an org with NO override. It is NOT the
+    // fallback the webapp uses when that fetch fails: `getPublicBooleanFlagServer`
+    // and `usePublicBooleanFlag` both return the argument passed at the CALL
+    // SITE and never consult this registry. Three call sites carry `true` to
+    // match — agents/[agentId]/page.tsx, agents/[agentId]/edit/page.tsx and
+    // `useAgentUnifiedScreenEnabled` in lib/redesign-flags.ts. Flipping the
+    // registry alone leaves the cutover half-applied with no error anywhere;
+    // eng-9832-unified-fallback-parity.test.ts fails if any of the three drifts.
+    defaultValue: true,
+    // Read BOTH server-side (agents/[agentId]/page.tsx and its /edit sibling, via
+    // getPublicBooleanFlagServer) and client-side (dashboard-sherlock-shell.tsx,
+    // via usePublicBooleanFlag), so the key must be in the browser-exposed public
+    // map. Additive viewer gate, resolved within the active-org cookie's scope
+    // — not sensitive.
+    //
+    // `public` MUST STAY until step 2 deletes the key, and the reason reads
+    // backwards: the server helper resolves against the very SAME public-filtered
+    // `GET /flags` the browser uses (routes/flags.ts filters to
+    // listPublicFlagKeys()). Drop `public` and the key is simply absent from the
+    // map, so both server readers fall through to their call-site argument
+    // forever — silently, with no error raised anywhere.
     public: true
   },
   {
@@ -30141,660 +30165,296 @@ var MIN_PROVISIONING_MAX_FOR_QUARANTINE_ORDERING = BIND_FAILURE_QUARANTINE_THRES
 var FORCED_UPDATE_RELAX_AFTER_MS = 7 * 6e4;
 var FORCED_UPDATE_HARD_DEADLINE_MS = 15 * 6e4;
 
-// ../core/dist/dashboards/widget-kinds.js
-var DASHBOARD_WIDGET_KINDS = ["kpi", "area", "line", "bar", "donut", "table"];
-var TABLE_CELL_STATES = ["good", "warning", "critical", "info", "neutral", "empty"];
-var TABLE_WIDGET_LIMITS = { columns: 60, rows: 500, label: 120, cellText: 64 };
-function categoriesSeriesSchema() {
-  return {
-    type: "object",
-    required: ["categories", "series"],
-    additionalProperties: false,
-    properties: {
-      categories: { type: "array", items: { type: "string" } },
-      series: {
-        type: "array",
-        items: {
-          type: "object",
-          required: ["name", "data"],
-          additionalProperties: false,
-          properties: {
-            name: { type: "string" },
-            data: { type: "array", items: { type: "number" } }
-          }
-        }
-      }
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
+var external_exports = {};
+__export(external_exports, {
+  BRAND: () => BRAND,
+  DIRTY: () => DIRTY,
+  EMPTY_PATH: () => EMPTY_PATH,
+  INVALID: () => INVALID,
+  NEVER: () => NEVER,
+  OK: () => OK,
+  ParseStatus: () => ParseStatus,
+  Schema: () => ZodType,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBigInt: () => ZodBigInt,
+  ZodBoolean: () => ZodBoolean,
+  ZodBranded: () => ZodBranded,
+  ZodCatch: () => ZodCatch,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodEffects: () => ZodEffects,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNativeEnum: () => ZodNativeEnum,
+  ZodNever: () => ZodNever,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodParsedType: () => ZodParsedType,
+  ZodPipeline: () => ZodPipeline,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRecord: () => ZodRecord,
+  ZodSchema: () => ZodType,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodSymbol: () => ZodSymbol,
+  ZodTransformer: () => ZodEffects,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  addIssueToContext: () => addIssueToContext,
+  any: () => anyType,
+  array: () => arrayType,
+  bigint: () => bigIntType,
+  boolean: () => booleanType,
+  coerce: () => coerce,
+  custom: () => custom,
+  date: () => dateType,
+  datetimeRegex: () => datetimeRegex,
+  defaultErrorMap: () => en_default,
+  discriminatedUnion: () => discriminatedUnionType,
+  effect: () => effectsType,
+  enum: () => enumType,
+  function: () => functionType,
+  getErrorMap: () => getErrorMap,
+  getParsedType: () => getParsedType,
+  instanceof: () => instanceOfType,
+  intersection: () => intersectionType,
+  isAborted: () => isAborted,
+  isAsync: () => isAsync,
+  isDirty: () => isDirty,
+  isValid: () => isValid,
+  late: () => late,
+  lazy: () => lazyType,
+  literal: () => literalType,
+  makeIssue: () => makeIssue,
+  map: () => mapType,
+  nan: () => nanType,
+  nativeEnum: () => nativeEnumType,
+  never: () => neverType,
+  null: () => nullType,
+  nullable: () => nullableType,
+  number: () => numberType,
+  object: () => objectType,
+  objectUtil: () => objectUtil,
+  oboolean: () => oboolean,
+  onumber: () => onumber,
+  optional: () => optionalType,
+  ostring: () => ostring,
+  pipeline: () => pipelineType,
+  preprocess: () => preprocessType,
+  promise: () => promiseType,
+  quotelessJson: () => quotelessJson,
+  record: () => recordType,
+  set: () => setType,
+  setErrorMap: () => setErrorMap,
+  strictObject: () => strictObjectType,
+  string: () => stringType,
+  symbol: () => symbolType,
+  transformer: () => effectsType,
+  tuple: () => tupleType,
+  undefined: () => undefinedType,
+  union: () => unionType,
+  unknown: () => unknownType,
+  util: () => util,
+  void: () => voidType
+});
+
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.js
+var util;
+(function(util2) {
+  util2.assertEqual = (_) => {
+  };
+  function assertIs2(_arg) {
+  }
+  util2.assertIs = assertIs2;
+  function assertNever2(_x) {
+    throw new Error();
+  }
+  util2.assertNever = assertNever2;
+  util2.arrayToEnum = (items) => {
+    const obj = {};
+    for (const item of items) {
+      obj[item] = item;
     }
+    return obj;
   };
-}
-function tableSchema() {
-  const L = TABLE_WIDGET_LIMITS;
-  return {
-    type: "object",
-    required: ["columns", "rows"],
-    additionalProperties: false,
-    properties: {
-      rowHeader: { type: "string", maxLength: L.label },
-      columns: { type: "array", minItems: 1, maxItems: L.columns, items: { type: "string", maxLength: L.label } },
-      rows: {
-        type: "array",
-        maxItems: L.rows,
-        items: {
-          type: "object",
-          required: ["label", "cells"],
-          additionalProperties: false,
-          properties: {
-            label: { type: "string", maxLength: L.label },
-            sub: { type: "string", maxLength: L.label },
-            cells: {
-              type: "array",
-              maxItems: L.columns,
-              items: {
-                type: "object",
-                additionalProperties: false,
-                properties: {
-                  value: { type: ["string", "number"], maxLength: L.cellText },
-                  sub: { type: "string", maxLength: L.cellText },
-                  state: { enum: [...TABLE_CELL_STATES] }
-                }
-              }
-            }
-          }
-        }
-      },
-      legend: {
-        type: "array",
-        maxItems: TABLE_CELL_STATES.length,
-        items: {
-          type: "object",
-          required: ["state", "label"],
-          additionalProperties: false,
-          properties: {
-            state: { enum: [...TABLE_CELL_STATES] },
-            label: { type: "string", maxLength: L.label }
-          }
-        }
-      }
+  util2.getValidEnumValues = (obj) => {
+    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+    const filtered = {};
+    for (const k of validKeys) {
+      filtered[k] = obj[k];
     }
+    return util2.objectValues(filtered);
   };
-}
-var DASHBOARD_WIDGET_SCHEMAS = {
-  kpi: {
-    type: "object",
-    required: ["value"],
-    additionalProperties: false,
-    properties: {
-      label: { type: "string" },
-      value: { type: ["string", "number"] },
-      delta: { type: "string" },
-      deltaTone: { enum: ["positive", "negative", "neutral"] },
-      values: { type: "array", items: { type: "number" } },
-      color: { type: "string", pattern: "^#[0-9a-fA-F]{6}$" }
+  util2.objectValues = (obj) => {
+    return util2.objectKeys(obj).map(function(e) {
+      return obj[e];
+    });
+  };
+  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object3) => {
+    const keys = [];
+    for (const key in object3) {
+      if (Object.prototype.hasOwnProperty.call(object3, key)) {
+        keys.push(key);
+      }
     }
-  },
-  area: categoriesSeriesSchema(),
-  line: categoriesSeriesSchema(),
-  bar: categoriesSeriesSchema(),
-  donut: {
-    type: "object",
-    required: ["labels", "series"],
-    additionalProperties: false,
-    properties: {
-      labels: { type: "array", items: { type: "string" } },
-      series: { type: "array", items: { type: "number" } }
+    return keys;
+  };
+  util2.find = (arr, checker) => {
+    for (const item of arr) {
+      if (checker(item))
+        return item;
     }
-  },
-  table: tableSchema()
-};
-
-// src/kanban-get-error.ts
-function kanbanGetErrorMessage(status, id, fallbackMessage) {
-  if (status === 400) return "A card id is required.";
-  if (status === 404) return `No card with id "${id}" on your board.`;
-  return `Could not read the card: ${fallbackMessage}`;
-}
-
-// src/knowledge-body-render.ts
-function renderKnowledgeBody(content) {
-  if (content === void 0 || content === null) {
-    return "(!) CONTRACT FAILURE: the API returned no `content` field for this entry. This is NOT an empty entry \u2014 the body was not delivered. Do not treat this as the entry text, and do not knowledge_update from it: an update replaces the whole body and would erase the real one. Report this as a bug.";
-  }
-  if (content.length === 0) {
-    return "(empty \u2014 this entry genuinely has no body text)";
+    return void 0;
+  };
+  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+  function joinValues2(array2, separator = " | ") {
+    return array2.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
   }
-  return content;
-}
-
-// src/index.ts
-import { homedir as homedir3 } from "os";
-import { basename, isAbsolute as isAbsolute2, join as join6, resolve as pathResolve, sep as sep2 } from "path";
-
-// src/host-file-path.ts
-var SKILL_BODY_PATH_MAX_BYTES = 512 * 1024;
-var AGT_LIVE_CONTENT_PATH_MAX_BYTES = 2 * 1024 * 1024;
-var HOST_FILE_PATH_TOOLS = /* @__PURE__ */ new Map([
-  [
-    "skill_create",
-    { pathArg: "body_path", targetArg: "body", maxBytes: SKILL_BODY_PATH_MAX_BYTES, label: "a skill body" }
-  ],
-  [
-    "skill_update",
-    { pathArg: "body_path", targetArg: "body", maxBytes: SKILL_BODY_PATH_MAX_BYTES, label: "a skill body" }
-  ],
-  [
-    "agt_live_publish",
-    {
-      pathArg: "content_path",
-      targetArg: "content",
-      maxBytes: AGT_LIVE_CONTENT_PATH_MAX_BYTES,
-      label: "a published page"
+  util2.joinValues = joinValues2;
+  util2.jsonStringifyReplacer = (_, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
     }
-  ]
-]);
-function hostFilePathArg(toolName) {
-  return HOST_FILE_PATH_TOOLS.get(toolName)?.pathArg;
-}
-function allowedHostFileRoots(agentDir, path) {
-  return [path.join(agentDir, "project"), path.join(agentDir, "scratch")];
-}
-function openContained(target, roots, opts) {
-  const { path, fs, procFdBase } = opts;
-  if (!procFdBase) {
+    return value;
+  };
+})(util || (util = {}));
+var objectUtil;
+(function(objectUtil2) {
+  objectUtil2.mergeShapes = (first, second) => {
     return {
-      ok: false,
-      error: "reading a host path needs descriptor-relative traversal (procfs), which this platform does not provide. Pass the content inline instead."
+      ...first,
+      ...second
+      // second overwrites first
     };
-  }
-  const root = roots.find((r) => isContained(target, r, path.sep));
-  if (!root) return { ok: false, error: "resolved outside the allowed roots" };
-  const segments = target.slice(root.length).split(path.sep).filter(Boolean);
-  const fileName = segments[segments.length - 1];
-  if (fileName === void 0) {
-    return { ok: false, error: `'${target}' is a directory, not a file` };
-  }
-  for (const segment of segments) {
-    if (segment === "." || segment === "..") {
-      return { ok: false, error: `'${target}' contains a '${segment}' component` };
-    }
-  }
-  const dirNames = segments.slice(0, -1);
-  let dirFd;
-  try {
-    dirFd = fs.openSync(root, opts.dirOpenFlags);
-  } catch (err) {
-    return { ok: false, error: `the allowed root '${root}' could not be opened \u2014 ${err.message}` };
-  }
-  try {
-    for (const name of dirNames) {
-      let nextFd;
-      try {
-        nextFd = fs.openSync(path.join(procFdBase, String(dirFd), name), opts.dirOpenFlags);
-      } catch (err) {
-        return {
-          ok: false,
-          error: `'${name}' could not be entered \u2014 it is a symlink, is not a directory, or was replaced mid-traversal (${err.message})`
-        };
+  };
+})(objectUtil || (objectUtil = {}));
+var ZodParsedType = util.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]);
+var getParsedType = (data) => {
+  const t = typeof data;
+  switch (t) {
+    case "undefined":
+      return ZodParsedType.undefined;
+    case "string":
+      return ZodParsedType.string;
+    case "number":
+      return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+    case "boolean":
+      return ZodParsedType.boolean;
+    case "function":
+      return ZodParsedType.function;
+    case "bigint":
+      return ZodParsedType.bigint;
+    case "symbol":
+      return ZodParsedType.symbol;
+    case "object":
+      if (Array.isArray(data)) {
+        return ZodParsedType.array;
       }
-      try {
-        fs.closeSync(dirFd);
-      } catch {
+      if (data === null) {
+        return ZodParsedType.null;
       }
-      dirFd = nextFd;
-    }
-    let fd;
-    try {
-      fd = fs.openSync(path.join(procFdBase, String(dirFd), fileName), opts.openFlags);
-    } catch (err) {
-      return {
-        ok: false,
-        error: `'${fileName}' could not be opened (a symlink, or replaced mid-check) \u2014 ${err.message}`
-      };
-    }
-    return { ok: true, fd };
-  } finally {
-    try {
-      fs.closeSync(dirFd);
-    } catch {
-    }
+      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+        return ZodParsedType.promise;
+      }
+      if (typeof Map !== "undefined" && data instanceof Map) {
+        return ZodParsedType.map;
+      }
+      if (typeof Set !== "undefined" && data instanceof Set) {
+        return ZodParsedType.set;
+      }
+      if (typeof Date !== "undefined" && data instanceof Date) {
+        return ZodParsedType.date;
+      }
+      return ZodParsedType.object;
+    default:
+      return ZodParsedType.unknown;
   }
-}
-function isContained(candidate, root, sep3) {
-  if (candidate === root) return true;
-  const rootWithSep = root.endsWith(sep3) ? root : root + sep3;
-  return candidate.startsWith(rootWithSep);
-}
-function resolveHostFilePath(toolName, args, opts) {
-  const spec = HOST_FILE_PATH_TOOLS.get(toolName);
-  if (!spec) return { ok: true, args };
-  const raw = args[spec.pathArg];
-  if (raw === void 0 || raw === null) return { ok: true, args };
-  if (typeof raw !== "string" || raw.trim() === "") {
-    return { ok: false, error: `${spec.pathArg} must be a non-empty string.` };
+};
+
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/ZodError.js
+var ZodIssueCode = util.arrayToEnum([
+  "invalid_type",
+  "invalid_literal",
+  "custom",
+  "invalid_union",
+  "invalid_union_discriminator",
+  "invalid_enum_value",
+  "unrecognized_keys",
+  "invalid_arguments",
+  "invalid_return_type",
+  "invalid_date",
+  "invalid_string",
+  "too_small",
+  "too_big",
+  "invalid_intersection_types",
+  "not_multiple_of",
+  "not_finite"
+]);
+var quotelessJson = (obj) => {
+  const json = JSON.stringify(obj, null, 2);
+  return json.replace(/"([^"]+)":/g, "$1:");
+};
+var ZodError = class _ZodError extends Error {
+  get errors() {
+    return this.issues;
   }
-  if (typeof args[spec.targetArg] === "string") {
-    return {
-      ok: false,
-      error: `Pass either ${spec.targetArg} or ${spec.pathArg}, not both \u2014 they are two ways to say the same thing and I will not guess which one you meant.`
+  constructor(issues) {
+    super();
+    this.issues = [];
+    this.addIssue = (sub) => {
+      this.issues = [...this.issues, sub];
     };
-  }
-  const { agentDir, path, fs } = opts;
-  const maxBytes = opts.maxBytes ?? spec.maxBytes;
-  const roots = allowedHostFileRoots(agentDir, path);
-  const absolute = path.isAbsolute(raw) ? path.resolve(raw) : path.resolve(path.join(agentDir, "project"), raw);
-  if (!roots.some((r) => isContained(absolute, r, path.sep))) {
-    return {
-      ok: false,
-      error: `${spec.pathArg} must be inside your own project or scratch directory. Got '${raw}'. Allowed: ${roots.join(", ")}`
+    this.addIssues = (subs = []) => {
+      this.issues = [...this.issues, ...subs];
     };
-  }
-  let real;
-  try {
-    real = fs.realpathSync(absolute);
-  } catch {
-    return { ok: false, error: `${spec.pathArg} does not exist or is unreadable: '${raw}'` };
-  }
-  if (!roots.some((r) => isContained(real, r, path.sep))) {
-    return {
-      ok: false,
-      error: `${spec.pathArg} resolves outside your own directories (symlink?). '${raw}' \u2192 '${real}'. Allowed: ${roots.join(", ")}`
-    };
-  }
-  const opened = openContained(real, roots, opts);
-  if (!opened.ok) return { ok: false, error: `${spec.pathArg}: ${opened.error} ('${raw}')` };
-  const fd = opened.fd;
-  try {
-    let stat;
-    try {
-      stat = fs.fstatSync(fd);
-    } catch {
-      return { ok: false, error: `${spec.pathArg} could not be inspected: '${raw}'` };
-    }
-    if (!stat.isFile()) {
-      return { ok: false, error: `${spec.pathArg} is not a regular file: '${raw}'` };
-    }
-    if (stat.size > maxBytes) {
-      return {
-        ok: false,
-        error: `${spec.pathArg} is ${stat.size} bytes, over the ${maxBytes}-byte limit for ${spec.label}.`
-      };
-    }
-    let bytes;
-    try {
-      bytes = fs.readFdSync(fd, maxBytes);
-    } catch (err) {
-      return { ok: false, error: `${spec.pathArg} could not be read: ${err.message}` };
-    }
-    if (bytes.byteLength > maxBytes) {
-      return { ok: false, error: `${spec.pathArg} grew past the ${maxBytes}-byte limit while being read.` };
-    }
-    const value = fs.decodeUtf8(bytes);
-    const next = { ...args, [spec.targetArg]: value };
-    delete next[spec.pathArg];
-    return { ok: true, args: next };
-  } finally {
-    try {
-      fs.closeSync(fd);
-    } catch {
-    }
-  }
-}
-
-// src/artefact-work-dir.ts
-import { mkdir, mkdtemp } from "fs/promises";
-import { existsSync } from "fs";
-import { dirname, join as join2 } from "path";
-
-// ../core/dist/provisioning/frameworks/claudecode/agent-dir-alias.js
-import { isAbsolute, join, relative, sep } from "path";
-var VALID_CODE_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var VALID_AGENT_ID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
-var INITIATOR_BASENAME = ".current-turn-initiator.json";
-function isSafeAgentSegment(segment) {
-  return VALID_CODE_NAME.test(segment) || VALID_AGENT_ID.test(segment);
-}
-function initiatorDirSegment(initiatorFile, homeDir) {
-  const rel = relative(join(homeDir, ".augmented"), initiatorFile);
-  if (!rel || isAbsolute(rel))
-    return null;
-  const parts = rel.split(sep);
-  if (parts.length !== 2 || parts[1] !== INITIATOR_BASENAME)
-    return null;
-  const segment = parts[0];
-  if (segment === void 0)
-    return null;
-  return isSafeAgentSegment(segment) ? segment : null;
-}
-function resolveAgentDirAlias(input) {
-  const { codeName, turnInitiatorFile, agentId, homeDir } = input;
-  const codeNameTrimmed = typeof codeName === "string" ? codeName.trim() : "";
-  if (codeNameTrimmed && VALID_CODE_NAME.test(codeNameTrimmed)) {
-    return join(homeDir, ".augmented", codeNameTrimmed);
-  }
-  const initiator = typeof turnInitiatorFile === "string" ? turnInitiatorFile.trim() : "";
-  if (initiator) {
-    const segment = initiatorDirSegment(initiator, homeDir);
-    if (segment)
-      return join(homeDir, ".augmented", segment);
-  }
-  const agentIdTrimmed = typeof agentId === "string" ? agentId.trim() : "";
-  if (agentIdTrimmed && VALID_AGENT_ID.test(agentIdTrimmed)) {
-    return join(homeDir, ".augmented", agentIdTrimmed);
-  }
-  return null;
-}
-function resolveAgentScratchDir(input) {
-  const alias = resolveAgentDirAlias(input);
-  return alias === null ? null : join(alias, "scratch");
-}
-
-// src/artefact-work-dir.ts
-async function makeArtefactWorkDir(prefix, env2) {
-  const scratch = resolveAgentScratchDir(env2);
-  if (scratch === null) {
-    throw new Error(
-      "Cannot save the artefact: none of AGT_AGENT_CODE_NAME, AGT_TURN_INITIATOR_FILE or AGT_AGENT_ID is set, so this server cannot tell which agent directory the file belongs in."
-    );
-  }
-  const agentDir = dirname(scratch);
-  if (!existsSync(agentDir)) {
-    throw new Error(
-      `Cannot save the artefact: the agent directory ${agentDir} does not exist on this host.`
-    );
-  }
-  await mkdir(scratch, { recursive: true });
-  return mkdtemp(join2(scratch, prefix));
-}
-
-// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
-var external_exports = {};
-__export(external_exports, {
-  BRAND: () => BRAND,
-  DIRTY: () => DIRTY,
-  EMPTY_PATH: () => EMPTY_PATH,
-  INVALID: () => INVALID,
-  NEVER: () => NEVER,
-  OK: () => OK,
-  ParseStatus: () => ParseStatus,
-  Schema: () => ZodType,
-  ZodAny: () => ZodAny,
-  ZodArray: () => ZodArray,
-  ZodBigInt: () => ZodBigInt,
-  ZodBoolean: () => ZodBoolean,
-  ZodBranded: () => ZodBranded,
-  ZodCatch: () => ZodCatch,
-  ZodDate: () => ZodDate,
-  ZodDefault: () => ZodDefault,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodEffects: () => ZodEffects,
-  ZodEnum: () => ZodEnum,
-  ZodError: () => ZodError,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodFunction: () => ZodFunction,
-  ZodIntersection: () => ZodIntersection,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodLazy: () => ZodLazy,
-  ZodLiteral: () => ZodLiteral,
-  ZodMap: () => ZodMap,
-  ZodNaN: () => ZodNaN,
-  ZodNativeEnum: () => ZodNativeEnum,
-  ZodNever: () => ZodNever,
-  ZodNull: () => ZodNull,
-  ZodNullable: () => ZodNullable,
-  ZodNumber: () => ZodNumber,
-  ZodObject: () => ZodObject,
-  ZodOptional: () => ZodOptional,
-  ZodParsedType: () => ZodParsedType,
-  ZodPipeline: () => ZodPipeline,
-  ZodPromise: () => ZodPromise,
-  ZodReadonly: () => ZodReadonly,
-  ZodRecord: () => ZodRecord,
-  ZodSchema: () => ZodType,
-  ZodSet: () => ZodSet,
-  ZodString: () => ZodString,
-  ZodSymbol: () => ZodSymbol,
-  ZodTransformer: () => ZodEffects,
-  ZodTuple: () => ZodTuple,
-  ZodType: () => ZodType,
-  ZodUndefined: () => ZodUndefined,
-  ZodUnion: () => ZodUnion,
-  ZodUnknown: () => ZodUnknown,
-  ZodVoid: () => ZodVoid,
-  addIssueToContext: () => addIssueToContext,
-  any: () => anyType,
-  array: () => arrayType,
-  bigint: () => bigIntType,
-  boolean: () => booleanType,
-  coerce: () => coerce,
-  custom: () => custom,
-  date: () => dateType,
-  datetimeRegex: () => datetimeRegex,
-  defaultErrorMap: () => en_default,
-  discriminatedUnion: () => discriminatedUnionType,
-  effect: () => effectsType,
-  enum: () => enumType,
-  function: () => functionType,
-  getErrorMap: () => getErrorMap,
-  getParsedType: () => getParsedType,
-  instanceof: () => instanceOfType,
-  intersection: () => intersectionType,
-  isAborted: () => isAborted,
-  isAsync: () => isAsync,
-  isDirty: () => isDirty,
-  isValid: () => isValid,
-  late: () => late,
-  lazy: () => lazyType,
-  literal: () => literalType,
-  makeIssue: () => makeIssue,
-  map: () => mapType,
-  nan: () => nanType,
-  nativeEnum: () => nativeEnumType,
-  never: () => neverType,
-  null: () => nullType,
-  nullable: () => nullableType,
-  number: () => numberType,
-  object: () => objectType,
-  objectUtil: () => objectUtil,
-  oboolean: () => oboolean,
-  onumber: () => onumber,
-  optional: () => optionalType,
-  ostring: () => ostring,
-  pipeline: () => pipelineType,
-  preprocess: () => preprocessType,
-  promise: () => promiseType,
-  quotelessJson: () => quotelessJson,
-  record: () => recordType,
-  set: () => setType,
-  setErrorMap: () => setErrorMap,
-  strictObject: () => strictObjectType,
-  string: () => stringType,
-  symbol: () => symbolType,
-  transformer: () => effectsType,
-  tuple: () => tupleType,
-  undefined: () => undefinedType,
-  union: () => unionType,
-  unknown: () => unknownType,
-  util: () => util,
-  void: () => voidType
-});
-
-// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.js
-var util;
-(function(util2) {
-  util2.assertEqual = (_) => {
-  };
-  function assertIs2(_arg) {
-  }
-  util2.assertIs = assertIs2;
-  function assertNever2(_x) {
-    throw new Error();
-  }
-  util2.assertNever = assertNever2;
-  util2.arrayToEnum = (items) => {
-    const obj = {};
-    for (const item of items) {
-      obj[item] = item;
-    }
-    return obj;
-  };
-  util2.getValidEnumValues = (obj) => {
-    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-    const filtered = {};
-    for (const k of validKeys) {
-      filtered[k] = obj[k];
-    }
-    return util2.objectValues(filtered);
-  };
-  util2.objectValues = (obj) => {
-    return util2.objectKeys(obj).map(function(e) {
-      return obj[e];
-    });
-  };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object3) => {
-    const keys = [];
-    for (const key in object3) {
-      if (Object.prototype.hasOwnProperty.call(object3, key)) {
-        keys.push(key);
-      }
-    }
-    return keys;
-  };
-  util2.find = (arr, checker) => {
-    for (const item of arr) {
-      if (checker(item))
-        return item;
-    }
-    return void 0;
-  };
-  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
-  function joinValues2(array2, separator = " | ") {
-    return array2.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
-  }
-  util2.joinValues = joinValues2;
-  util2.jsonStringifyReplacer = (_, value) => {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    return value;
-  };
-})(util || (util = {}));
-var objectUtil;
-(function(objectUtil2) {
-  objectUtil2.mergeShapes = (first, second) => {
-    return {
-      ...first,
-      ...second
-      // second overwrites first
-    };
-  };
-})(objectUtil || (objectUtil = {}));
-var ZodParsedType = util.arrayToEnum([
-  "string",
-  "nan",
-  "number",
-  "integer",
-  "float",
-  "boolean",
-  "date",
-  "bigint",
-  "symbol",
-  "function",
-  "undefined",
-  "null",
-  "array",
-  "object",
-  "unknown",
-  "promise",
-  "void",
-  "never",
-  "map",
-  "set"
-]);
-var getParsedType = (data) => {
-  const t = typeof data;
-  switch (t) {
-    case "undefined":
-      return ZodParsedType.undefined;
-    case "string":
-      return ZodParsedType.string;
-    case "number":
-      return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
-    case "boolean":
-      return ZodParsedType.boolean;
-    case "function":
-      return ZodParsedType.function;
-    case "bigint":
-      return ZodParsedType.bigint;
-    case "symbol":
-      return ZodParsedType.symbol;
-    case "object":
-      if (Array.isArray(data)) {
-        return ZodParsedType.array;
-      }
-      if (data === null) {
-        return ZodParsedType.null;
-      }
-      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
-        return ZodParsedType.promise;
-      }
-      if (typeof Map !== "undefined" && data instanceof Map) {
-        return ZodParsedType.map;
-      }
-      if (typeof Set !== "undefined" && data instanceof Set) {
-        return ZodParsedType.set;
-      }
-      if (typeof Date !== "undefined" && data instanceof Date) {
-        return ZodParsedType.date;
-      }
-      return ZodParsedType.object;
-    default:
-      return ZodParsedType.unknown;
-  }
-};
-
-// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/ZodError.js
-var ZodIssueCode = util.arrayToEnum([
-  "invalid_type",
-  "invalid_literal",
-  "custom",
-  "invalid_union",
-  "invalid_union_discriminator",
-  "invalid_enum_value",
-  "unrecognized_keys",
-  "invalid_arguments",
-  "invalid_return_type",
-  "invalid_date",
-  "invalid_string",
-  "too_small",
-  "too_big",
-  "invalid_intersection_types",
-  "not_multiple_of",
-  "not_finite"
-]);
-var quotelessJson = (obj) => {
-  const json = JSON.stringify(obj, null, 2);
-  return json.replace(/"([^"]+)":/g, "$1:");
-};
-var ZodError = class _ZodError extends Error {
-  get errors() {
-    return this.issues;
-  }
-  constructor(issues) {
-    super();
-    this.issues = [];
-    this.addIssue = (sub) => {
-      this.issues = [...this.issues, sub];
-    };
-    this.addIssues = (subs = []) => {
-      this.issues = [...this.issues, ...subs];
-    };
-    const actualProto = new.target.prototype;
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(this, actualProto);
-    } else {
-      this.__proto__ = actualProto;
-    }
-    this.name = "ZodError";
-    this.issues = issues;
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      this.__proto__ = actualProto;
+    }
+    this.name = "ZodError";
+    this.issues = issues;
   }
   format(_mapper) {
     const mapper = _mapper || function(issue2) {
@@ -33743,808 +33403,1203 @@ var ZodSet = class _ZodSet extends ZodType {
       return finalizeSet(elements);
     }
   }
-  min(minSize, message) {
-    return new _ZodSet({
+  min(minSize, message) {
+    return new _ZodSet({
+      ...this._def,
+      minSize: { value: minSize, message: errorUtil.toString(message) }
+    });
+  }
+  max(maxSize, message) {
+    return new _ZodSet({
+      ...this._def,
+      maxSize: { value: maxSize, message: errorUtil.toString(message) }
+    });
+  }
+  size(size, message) {
+    return this.min(size, message).max(size, message);
+  }
+  nonempty(message) {
+    return this.min(1, message);
+  }
+};
+ZodSet.create = (valueType, params) => {
+  return new ZodSet({
+    valueType,
+    minSize: null,
+    maxSize: null,
+    typeName: ZodFirstPartyTypeKind.ZodSet,
+    ...processCreateParams(params)
+  });
+};
+var ZodFunction = class _ZodFunction extends ZodType {
+  constructor() {
+    super(...arguments);
+    this.validate = this.implement;
+  }
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.function) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.function,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    function makeArgsIssue(args, error2) {
+      return makeIssue({
+        data: args,
+        path: ctx.path,
+        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
+        issueData: {
+          code: ZodIssueCode.invalid_arguments,
+          argumentsError: error2
+        }
+      });
+    }
+    function makeReturnsIssue(returns, error2) {
+      return makeIssue({
+        data: returns,
+        path: ctx.path,
+        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
+        issueData: {
+          code: ZodIssueCode.invalid_return_type,
+          returnTypeError: error2
+        }
+      });
+    }
+    const params = { errorMap: ctx.common.contextualErrorMap };
+    const fn = ctx.data;
+    if (this._def.returns instanceof ZodPromise) {
+      const me = this;
+      return OK(async function(...args) {
+        const error2 = new ZodError([]);
+        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
+          error2.addIssue(makeArgsIssue(args, e));
+          throw error2;
+        });
+        const result = await Reflect.apply(fn, this, parsedArgs);
+        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
+          error2.addIssue(makeReturnsIssue(result, e));
+          throw error2;
+        });
+        return parsedReturns;
+      });
+    } else {
+      const me = this;
+      return OK(function(...args) {
+        const parsedArgs = me._def.args.safeParse(args, params);
+        if (!parsedArgs.success) {
+          throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
+        }
+        const result = Reflect.apply(fn, this, parsedArgs.data);
+        const parsedReturns = me._def.returns.safeParse(result, params);
+        if (!parsedReturns.success) {
+          throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
+        }
+        return parsedReturns.data;
+      });
+    }
+  }
+  parameters() {
+    return this._def.args;
+  }
+  returnType() {
+    return this._def.returns;
+  }
+  args(...items) {
+    return new _ZodFunction({
+      ...this._def,
+      args: ZodTuple.create(items).rest(ZodUnknown.create())
+    });
+  }
+  returns(returnType) {
+    return new _ZodFunction({
+      ...this._def,
+      returns: returnType
+    });
+  }
+  implement(func) {
+    const validatedFunc = this.parse(func);
+    return validatedFunc;
+  }
+  strictImplement(func) {
+    const validatedFunc = this.parse(func);
+    return validatedFunc;
+  }
+  static create(args, returns, params) {
+    return new _ZodFunction({
+      args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
+      returns: returns || ZodUnknown.create(),
+      typeName: ZodFirstPartyTypeKind.ZodFunction,
+      ...processCreateParams(params)
+    });
+  }
+};
+var ZodLazy = class extends ZodType {
+  get schema() {
+    return this._def.getter();
+  }
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const lazySchema = this._def.getter();
+    return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
+  }
+};
+ZodLazy.create = (getter, params) => {
+  return new ZodLazy({
+    getter,
+    typeName: ZodFirstPartyTypeKind.ZodLazy,
+    ...processCreateParams(params)
+  });
+};
+var ZodLiteral = class extends ZodType {
+  _parse(input) {
+    if (input.data !== this._def.value) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        received: ctx.data,
+        code: ZodIssueCode.invalid_literal,
+        expected: this._def.value
+      });
+      return INVALID;
+    }
+    return { status: "valid", value: input.data };
+  }
+  get value() {
+    return this._def.value;
+  }
+};
+ZodLiteral.create = (value, params) => {
+  return new ZodLiteral({
+    value,
+    typeName: ZodFirstPartyTypeKind.ZodLiteral,
+    ...processCreateParams(params)
+  });
+};
+function createZodEnum(values, params) {
+  return new ZodEnum({
+    values,
+    typeName: ZodFirstPartyTypeKind.ZodEnum,
+    ...processCreateParams(params)
+  });
+}
+var ZodEnum = class _ZodEnum extends ZodType {
+  _parse(input) {
+    if (typeof input.data !== "string") {
+      const ctx = this._getOrReturnCtx(input);
+      const expectedValues = this._def.values;
+      addIssueToContext(ctx, {
+        expected: util.joinValues(expectedValues),
+        received: ctx.parsedType,
+        code: ZodIssueCode.invalid_type
+      });
+      return INVALID;
+    }
+    if (!this._cache) {
+      this._cache = new Set(this._def.values);
+    }
+    if (!this._cache.has(input.data)) {
+      const ctx = this._getOrReturnCtx(input);
+      const expectedValues = this._def.values;
+      addIssueToContext(ctx, {
+        received: ctx.data,
+        code: ZodIssueCode.invalid_enum_value,
+        options: expectedValues
+      });
+      return INVALID;
+    }
+    return OK(input.data);
+  }
+  get options() {
+    return this._def.values;
+  }
+  get enum() {
+    const enumValues = {};
+    for (const val of this._def.values) {
+      enumValues[val] = val;
+    }
+    return enumValues;
+  }
+  get Values() {
+    const enumValues = {};
+    for (const val of this._def.values) {
+      enumValues[val] = val;
+    }
+    return enumValues;
+  }
+  get Enum() {
+    const enumValues = {};
+    for (const val of this._def.values) {
+      enumValues[val] = val;
+    }
+    return enumValues;
+  }
+  extract(values, newDef = this._def) {
+    return _ZodEnum.create(values, {
       ...this._def,
-      minSize: { value: minSize, message: errorUtil.toString(message) }
+      ...newDef
     });
   }
-  max(maxSize, message) {
-    return new _ZodSet({
+  exclude(values, newDef = this._def) {
+    return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
       ...this._def,
-      maxSize: { value: maxSize, message: errorUtil.toString(message) }
+      ...newDef
     });
   }
-  size(size, message) {
-    return this.min(size, message).max(size, message);
+};
+ZodEnum.create = createZodEnum;
+var ZodNativeEnum = class extends ZodType {
+  _parse(input) {
+    const nativeEnumValues = util.getValidEnumValues(this._def.values);
+    const ctx = this._getOrReturnCtx(input);
+    if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
+      const expectedValues = util.objectValues(nativeEnumValues);
+      addIssueToContext(ctx, {
+        expected: util.joinValues(expectedValues),
+        received: ctx.parsedType,
+        code: ZodIssueCode.invalid_type
+      });
+      return INVALID;
+    }
+    if (!this._cache) {
+      this._cache = new Set(util.getValidEnumValues(this._def.values));
+    }
+    if (!this._cache.has(input.data)) {
+      const expectedValues = util.objectValues(nativeEnumValues);
+      addIssueToContext(ctx, {
+        received: ctx.data,
+        code: ZodIssueCode.invalid_enum_value,
+        options: expectedValues
+      });
+      return INVALID;
+    }
+    return OK(input.data);
   }
-  nonempty(message) {
-    return this.min(1, message);
+  get enum() {
+    return this._def.values;
   }
 };
-ZodSet.create = (valueType, params) => {
-  return new ZodSet({
-    valueType,
-    minSize: null,
-    maxSize: null,
-    typeName: ZodFirstPartyTypeKind.ZodSet,
+ZodNativeEnum.create = (values, params) => {
+  return new ZodNativeEnum({
+    values,
+    typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
     ...processCreateParams(params)
   });
 };
-var ZodFunction = class _ZodFunction extends ZodType {
-  constructor() {
-    super(...arguments);
-    this.validate = this.implement;
+var ZodPromise = class extends ZodType {
+  unwrap() {
+    return this._def.type;
   }
   _parse(input) {
     const { ctx } = this._processInputParams(input);
-    if (ctx.parsedType !== ZodParsedType.function) {
+    if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.function,
+        expected: ZodParsedType.promise,
         received: ctx.parsedType
       });
       return INVALID;
     }
-    function makeArgsIssue(args, error2) {
-      return makeIssue({
-        data: args,
+    const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
+    return OK(promisified.then((data) => {
+      return this._def.type.parseAsync(data, {
         path: ctx.path,
-        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
-        issueData: {
-          code: ZodIssueCode.invalid_arguments,
-          argumentsError: error2
-        }
+        errorMap: ctx.common.contextualErrorMap
       });
-    }
-    function makeReturnsIssue(returns, error2) {
-      return makeIssue({
-        data: returns,
-        path: ctx.path,
-        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
-        issueData: {
-          code: ZodIssueCode.invalid_return_type,
-          returnTypeError: error2
+    }));
+  }
+};
+ZodPromise.create = (schema, params) => {
+  return new ZodPromise({
+    type: schema,
+    typeName: ZodFirstPartyTypeKind.ZodPromise,
+    ...processCreateParams(params)
+  });
+};
+var ZodEffects = class extends ZodType {
+  innerType() {
+    return this._def.schema;
+  }
+  sourceType() {
+    return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  }
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    const effect = this._def.effect || null;
+    const checkCtx = {
+      addIssue: (arg) => {
+        addIssueToContext(ctx, arg);
+        if (arg.fatal) {
+          status.abort();
+        } else {
+          status.dirty();
         }
-      });
-    }
-    const params = { errorMap: ctx.common.contextualErrorMap };
-    const fn = ctx.data;
-    if (this._def.returns instanceof ZodPromise) {
-      const me = this;
-      return OK(async function(...args) {
-        const error2 = new ZodError([]);
-        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
-          error2.addIssue(makeArgsIssue(args, e));
-          throw error2;
+      },
+      get path() {
+        return ctx.path;
+      }
+    };
+    checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
+    if (effect.type === "preprocess") {
+      const processed = effect.transform(ctx.data, checkCtx);
+      if (ctx.common.async) {
+        return Promise.resolve(processed).then(async (processed2) => {
+          if (status.value === "aborted")
+            return INVALID;
+          const result = await this._def.schema._parseAsync({
+            data: processed2,
+            path: ctx.path,
+            parent: ctx
+          });
+          if (result.status === "aborted")
+            return INVALID;
+          if (result.status === "dirty")
+            return DIRTY(result.value);
+          if (status.value === "dirty")
+            return DIRTY(result.value);
+          return result;
         });
-        const result = await Reflect.apply(fn, this, parsedArgs);
-        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
-          error2.addIssue(makeReturnsIssue(result, e));
-          throw error2;
+      } else {
+        if (status.value === "aborted")
+          return INVALID;
+        const result = this._def.schema._parseSync({
+          data: processed,
+          path: ctx.path,
+          parent: ctx
         });
-        return parsedReturns;
-      });
-    } else {
-      const me = this;
-      return OK(function(...args) {
-        const parsedArgs = me._def.args.safeParse(args, params);
-        if (!parsedArgs.success) {
-          throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
+        if (result.status === "aborted")
+          return INVALID;
+        if (result.status === "dirty")
+          return DIRTY(result.value);
+        if (status.value === "dirty")
+          return DIRTY(result.value);
+        return result;
+      }
+    }
+    if (effect.type === "refinement") {
+      const executeRefinement = (acc) => {
+        const result = effect.refinement(acc, checkCtx);
+        if (ctx.common.async) {
+          return Promise.resolve(result);
         }
-        const result = Reflect.apply(fn, this, parsedArgs.data);
-        const parsedReturns = me._def.returns.safeParse(result, params);
-        if (!parsedReturns.success) {
-          throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
+        if (result instanceof Promise) {
+          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
         }
-        return parsedReturns.data;
-      });
+        return acc;
+      };
+      if (ctx.common.async === false) {
+        const inner = this._def.schema._parseSync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (inner.status === "aborted")
+          return INVALID;
+        if (inner.status === "dirty")
+          status.dirty();
+        executeRefinement(inner.value);
+        return { status: status.value, value: inner.value };
+      } else {
+        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
+          if (inner.status === "aborted")
+            return INVALID;
+          if (inner.status === "dirty")
+            status.dirty();
+          return executeRefinement(inner.value).then(() => {
+            return { status: status.value, value: inner.value };
+          });
+        });
+      }
     }
-  }
-  parameters() {
-    return this._def.args;
-  }
-  returnType() {
-    return this._def.returns;
-  }
-  args(...items) {
-    return new _ZodFunction({
-      ...this._def,
-      args: ZodTuple.create(items).rest(ZodUnknown.create())
-    });
-  }
-  returns(returnType) {
-    return new _ZodFunction({
-      ...this._def,
-      returns: returnType
-    });
-  }
-  implement(func) {
-    const validatedFunc = this.parse(func);
-    return validatedFunc;
-  }
-  strictImplement(func) {
-    const validatedFunc = this.parse(func);
-    return validatedFunc;
-  }
-  static create(args, returns, params) {
-    return new _ZodFunction({
-      args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
-      returns: returns || ZodUnknown.create(),
-      typeName: ZodFirstPartyTypeKind.ZodFunction,
-      ...processCreateParams(params)
-    });
+    if (effect.type === "transform") {
+      if (ctx.common.async === false) {
+        const base = this._def.schema._parseSync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (!isValid(base))
+          return INVALID;
+        const result = effect.transform(base.value, checkCtx);
+        if (result instanceof Promise) {
+          throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
+        }
+        return { status: status.value, value: result };
+      } else {
+        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
+          if (!isValid(base))
+            return INVALID;
+          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
+            status: status.value,
+            value: result
+          }));
+        });
+      }
+    }
+    util.assertNever(effect);
   }
 };
-var ZodLazy = class extends ZodType {
-  get schema() {
-    return this._def.getter();
-  }
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    const lazySchema = this._def.getter();
-    return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
-  }
+ZodEffects.create = (schema, effect, params) => {
+  return new ZodEffects({
+    schema,
+    typeName: ZodFirstPartyTypeKind.ZodEffects,
+    effect,
+    ...processCreateParams(params)
+  });
 };
-ZodLazy.create = (getter, params) => {
-  return new ZodLazy({
-    getter,
-    typeName: ZodFirstPartyTypeKind.ZodLazy,
+ZodEffects.createWithPreprocess = (preprocess2, schema, params) => {
+  return new ZodEffects({
+    schema,
+    effect: { type: "preprocess", transform: preprocess2 },
+    typeName: ZodFirstPartyTypeKind.ZodEffects,
     ...processCreateParams(params)
   });
 };
-var ZodLiteral = class extends ZodType {
+var ZodOptional = class extends ZodType {
   _parse(input) {
-    if (input.data !== this._def.value) {
-      const ctx = this._getOrReturnCtx(input);
-      addIssueToContext(ctx, {
-        received: ctx.data,
-        code: ZodIssueCode.invalid_literal,
-        expected: this._def.value
-      });
-      return INVALID;
+    const parsedType2 = this._getType(input);
+    if (parsedType2 === ZodParsedType.undefined) {
+      return OK(void 0);
     }
-    return { status: "valid", value: input.data };
+    return this._def.innerType._parse(input);
   }
-  get value() {
-    return this._def.value;
+  unwrap() {
+    return this._def.innerType;
   }
 };
-ZodLiteral.create = (value, params) => {
-  return new ZodLiteral({
-    value,
-    typeName: ZodFirstPartyTypeKind.ZodLiteral,
+ZodOptional.create = (type, params) => {
+  return new ZodOptional({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodOptional,
     ...processCreateParams(params)
   });
 };
-function createZodEnum(values, params) {
-  return new ZodEnum({
-    values,
-    typeName: ZodFirstPartyTypeKind.ZodEnum,
-    ...processCreateParams(params)
-  });
-}
-var ZodEnum = class _ZodEnum extends ZodType {
+var ZodNullable = class extends ZodType {
   _parse(input) {
-    if (typeof input.data !== "string") {
-      const ctx = this._getOrReturnCtx(input);
-      const expectedValues = this._def.values;
-      addIssueToContext(ctx, {
-        expected: util.joinValues(expectedValues),
-        received: ctx.parsedType,
-        code: ZodIssueCode.invalid_type
-      });
-      return INVALID;
-    }
-    if (!this._cache) {
-      this._cache = new Set(this._def.values);
-    }
-    if (!this._cache.has(input.data)) {
-      const ctx = this._getOrReturnCtx(input);
-      const expectedValues = this._def.values;
-      addIssueToContext(ctx, {
-        received: ctx.data,
-        code: ZodIssueCode.invalid_enum_value,
-        options: expectedValues
-      });
-      return INVALID;
-    }
-    return OK(input.data);
-  }
-  get options() {
-    return this._def.values;
-  }
-  get enum() {
-    const enumValues = {};
-    for (const val of this._def.values) {
-      enumValues[val] = val;
+    const parsedType2 = this._getType(input);
+    if (parsedType2 === ZodParsedType.null) {
+      return OK(null);
     }
-    return enumValues;
+    return this._def.innerType._parse(input);
   }
-  get Values() {
-    const enumValues = {};
-    for (const val of this._def.values) {
-      enumValues[val] = val;
-    }
-    return enumValues;
+  unwrap() {
+    return this._def.innerType;
   }
-  get Enum() {
-    const enumValues = {};
-    for (const val of this._def.values) {
-      enumValues[val] = val;
+};
+ZodNullable.create = (type, params) => {
+  return new ZodNullable({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodNullable,
+    ...processCreateParams(params)
+  });
+};
+var ZodDefault = class extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    let data = ctx.data;
+    if (ctx.parsedType === ZodParsedType.undefined) {
+      data = this._def.defaultValue();
     }
-    return enumValues;
-  }
-  extract(values, newDef = this._def) {
-    return _ZodEnum.create(values, {
-      ...this._def,
-      ...newDef
+    return this._def.innerType._parse({
+      data,
+      path: ctx.path,
+      parent: ctx
     });
   }
-  exclude(values, newDef = this._def) {
-    return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
-      ...this._def,
-      ...newDef
-    });
+  removeDefault() {
+    return this._def.innerType;
   }
 };
-ZodEnum.create = createZodEnum;
-var ZodNativeEnum = class extends ZodType {
+ZodDefault.create = (type, params) => {
+  return new ZodDefault({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodDefault,
+    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+    ...processCreateParams(params)
+  });
+};
+var ZodCatch = class extends ZodType {
   _parse(input) {
-    const nativeEnumValues = util.getValidEnumValues(this._def.values);
-    const ctx = this._getOrReturnCtx(input);
-    if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
-      const expectedValues = util.objectValues(nativeEnumValues);
-      addIssueToContext(ctx, {
-        expected: util.joinValues(expectedValues),
-        received: ctx.parsedType,
-        code: ZodIssueCode.invalid_type
-      });
-      return INVALID;
-    }
-    if (!this._cache) {
-      this._cache = new Set(util.getValidEnumValues(this._def.values));
-    }
-    if (!this._cache.has(input.data)) {
-      const expectedValues = util.objectValues(nativeEnumValues);
-      addIssueToContext(ctx, {
-        received: ctx.data,
-        code: ZodIssueCode.invalid_enum_value,
-        options: expectedValues
+    const { ctx } = this._processInputParams(input);
+    const newCtx = {
+      ...ctx,
+      common: {
+        ...ctx.common,
+        issues: []
+      }
+    };
+    const result = this._def.innerType._parse({
+      data: newCtx.data,
+      path: newCtx.path,
+      parent: {
+        ...newCtx
+      }
+    });
+    if (isAsync(result)) {
+      return result.then((result2) => {
+        return {
+          status: "valid",
+          value: result2.status === "valid" ? result2.value : this._def.catchValue({
+            get error() {
+              return new ZodError(newCtx.common.issues);
+            },
+            input: newCtx.data
+          })
+        };
       });
-      return INVALID;
+    } else {
+      return {
+        status: "valid",
+        value: result.status === "valid" ? result.value : this._def.catchValue({
+          get error() {
+            return new ZodError(newCtx.common.issues);
+          },
+          input: newCtx.data
+        })
+      };
     }
-    return OK(input.data);
   }
-  get enum() {
-    return this._def.values;
+  removeCatch() {
+    return this._def.innerType;
   }
 };
-ZodNativeEnum.create = (values, params) => {
-  return new ZodNativeEnum({
-    values,
-    typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
+ZodCatch.create = (type, params) => {
+  return new ZodCatch({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodCatch,
+    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
     ...processCreateParams(params)
   });
 };
-var ZodPromise = class extends ZodType {
-  unwrap() {
-    return this._def.type;
-  }
+var ZodNaN = class extends ZodType {
   _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
+    const parsedType2 = this._getType(input);
+    if (parsedType2 !== ZodParsedType.nan) {
+      const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.promise,
+        expected: ZodParsedType.nan,
         received: ctx.parsedType
       });
       return INVALID;
     }
-    const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
-    return OK(promisified.then((data) => {
-      return this._def.type.parseAsync(data, {
-        path: ctx.path,
-        errorMap: ctx.common.contextualErrorMap
-      });
-    }));
+    return { status: "valid", value: input.data };
   }
 };
-ZodPromise.create = (schema, params) => {
-  return new ZodPromise({
-    type: schema,
-    typeName: ZodFirstPartyTypeKind.ZodPromise,
+ZodNaN.create = (params) => {
+  return new ZodNaN({
+    typeName: ZodFirstPartyTypeKind.ZodNaN,
     ...processCreateParams(params)
   });
 };
-var ZodEffects = class extends ZodType {
-  innerType() {
-    return this._def.schema;
+var BRAND = /* @__PURE__ */ Symbol("zod_brand");
+var ZodBranded = class extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const data = ctx.data;
+    return this._def.type._parse({
+      data,
+      path: ctx.path,
+      parent: ctx
+    });
   }
-  sourceType() {
-    return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  unwrap() {
+    return this._def.type;
   }
+};
+var ZodPipeline = class _ZodPipeline extends ZodType {
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
-    const effect = this._def.effect || null;
-    const checkCtx = {
-      addIssue: (arg) => {
-        addIssueToContext(ctx, arg);
-        if (arg.fatal) {
-          status.abort();
-        } else {
+    if (ctx.common.async) {
+      const handleAsync = async () => {
+        const inResult = await this._def.in._parseAsync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (inResult.status === "aborted")
+          return INVALID;
+        if (inResult.status === "dirty") {
           status.dirty();
-        }
-      },
-      get path() {
-        return ctx.path;
-      }
-    };
-    checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
-    if (effect.type === "preprocess") {
-      const processed = effect.transform(ctx.data, checkCtx);
-      if (ctx.common.async) {
-        return Promise.resolve(processed).then(async (processed2) => {
-          if (status.value === "aborted")
-            return INVALID;
-          const result = await this._def.schema._parseAsync({
-            data: processed2,
+          return DIRTY(inResult.value);
+        } else {
+          return this._def.out._parseAsync({
+            data: inResult.value,
             path: ctx.path,
             parent: ctx
           });
-          if (result.status === "aborted")
-            return INVALID;
-          if (result.status === "dirty")
-            return DIRTY(result.value);
-          if (status.value === "dirty")
-            return DIRTY(result.value);
-          return result;
-        });
+        }
+      };
+      return handleAsync();
+    } else {
+      const inResult = this._def.in._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      });
+      if (inResult.status === "aborted")
+        return INVALID;
+      if (inResult.status === "dirty") {
+        status.dirty();
+        return {
+          status: "dirty",
+          value: inResult.value
+        };
       } else {
-        if (status.value === "aborted")
-          return INVALID;
-        const result = this._def.schema._parseSync({
-          data: processed,
+        return this._def.out._parseSync({
+          data: inResult.value,
           path: ctx.path,
           parent: ctx
         });
-        if (result.status === "aborted")
-          return INVALID;
-        if (result.status === "dirty")
-          return DIRTY(result.value);
-        if (status.value === "dirty")
-          return DIRTY(result.value);
-        return result;
       }
     }
-    if (effect.type === "refinement") {
-      const executeRefinement = (acc) => {
-        const result = effect.refinement(acc, checkCtx);
-        if (ctx.common.async) {
-          return Promise.resolve(result);
+  }
+  static create(a, b) {
+    return new _ZodPipeline({
+      in: a,
+      out: b,
+      typeName: ZodFirstPartyTypeKind.ZodPipeline
+    });
+  }
+};
+var ZodReadonly = class extends ZodType {
+  _parse(input) {
+    const result = this._def.innerType._parse(input);
+    const freeze = (data) => {
+      if (isValid(data)) {
+        data.value = Object.freeze(data.value);
+      }
+      return data;
+    };
+    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+};
+ZodReadonly.create = (type, params) => {
+  return new ZodReadonly({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodReadonly,
+    ...processCreateParams(params)
+  });
+};
+function cleanParams(params, data) {
+  const p2 = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+  const p22 = typeof p2 === "string" ? { message: p2 } : p2;
+  return p22;
+}
+function custom(check2, _params = {}, fatal) {
+  if (check2)
+    return ZodAny.create().superRefine((data, ctx) => {
+      const r = check2(data);
+      if (r instanceof Promise) {
+        return r.then((r2) => {
+          if (!r2) {
+            const params = cleanParams(_params, data);
+            const _fatal = params.fatal ?? fatal ?? true;
+            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+          }
+        });
+      }
+      if (!r) {
+        const params = cleanParams(_params, data);
+        const _fatal = params.fatal ?? fatal ?? true;
+        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+      }
+      return;
+    });
+  return ZodAny.create();
+}
+var late = {
+  object: ZodObject.lazycreate
+};
+var ZodFirstPartyTypeKind;
+(function(ZodFirstPartyTypeKind2) {
+  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
+  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
+  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
+  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
+  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
+  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
+  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
+  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
+  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
+  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
+  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
+  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
+  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
+  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
+  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
+  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
+  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
+  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
+  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
+  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
+  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
+  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
+  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
+  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
+  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
+  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
+  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
+  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
+  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
+  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
+  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
+  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
+  ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
+  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
+  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
+})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+var instanceOfType = (cls, params = {
+  message: `Input not instance of ${cls.name}`
+}) => custom((data) => data instanceof cls, params);
+var stringType = ZodString.create;
+var numberType = ZodNumber.create;
+var nanType = ZodNaN.create;
+var bigIntType = ZodBigInt.create;
+var booleanType = ZodBoolean.create;
+var dateType = ZodDate.create;
+var symbolType = ZodSymbol.create;
+var undefinedType = ZodUndefined.create;
+var nullType = ZodNull.create;
+var anyType = ZodAny.create;
+var unknownType = ZodUnknown.create;
+var neverType = ZodNever.create;
+var voidType = ZodVoid.create;
+var arrayType = ZodArray.create;
+var objectType = ZodObject.create;
+var strictObjectType = ZodObject.strictCreate;
+var unionType = ZodUnion.create;
+var discriminatedUnionType = ZodDiscriminatedUnion.create;
+var intersectionType = ZodIntersection.create;
+var tupleType = ZodTuple.create;
+var recordType = ZodRecord.create;
+var mapType = ZodMap.create;
+var setType = ZodSet.create;
+var functionType = ZodFunction.create;
+var lazyType = ZodLazy.create;
+var literalType = ZodLiteral.create;
+var enumType = ZodEnum.create;
+var nativeEnumType = ZodNativeEnum.create;
+var promiseType = ZodPromise.create;
+var effectsType = ZodEffects.create;
+var optionalType = ZodOptional.create;
+var nullableType = ZodNullable.create;
+var preprocessType = ZodEffects.createWithPreprocess;
+var pipelineType = ZodPipeline.create;
+var ostring = () => stringType().optional();
+var onumber = () => numberType().optional();
+var oboolean = () => booleanType().optional();
+var coerce = {
+  string: ((arg) => ZodString.create({ ...arg, coerce: true })),
+  number: ((arg) => ZodNumber.create({ ...arg, coerce: true })),
+  boolean: ((arg) => ZodBoolean.create({
+    ...arg,
+    coerce: true
+  })),
+  bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })),
+  date: ((arg) => ZodDate.create({ ...arg, coerce: true }))
+};
+var NEVER = INVALID;
+
+// ../core/dist/dashboards/widget-kinds.js
+var DASHBOARD_WIDGET_KINDS = ["kpi", "area", "line", "bar", "donut", "table"];
+var TABLE_CELL_STATES = ["good", "warning", "critical", "info", "neutral", "empty"];
+var TABLE_WIDGET_LIMITS = { columns: 60, rows: 500, label: 120, cellText: 64 };
+function categoriesSeriesSchema() {
+  return {
+    type: "object",
+    required: ["categories", "series"],
+    additionalProperties: false,
+    properties: {
+      categories: { type: "array", items: { type: "string" } },
+      series: {
+        type: "array",
+        items: {
+          type: "object",
+          required: ["name", "data"],
+          additionalProperties: false,
+          properties: {
+            name: { type: "string" },
+            data: { type: "array", items: { type: "number" } }
+          }
+        }
+      }
+    }
+  };
+}
+function tableSchema() {
+  const L = TABLE_WIDGET_LIMITS;
+  return {
+    type: "object",
+    required: ["columns", "rows"],
+    additionalProperties: false,
+    properties: {
+      rowHeader: { type: "string", maxLength: L.label },
+      columns: { type: "array", minItems: 1, maxItems: L.columns, items: { type: "string", maxLength: L.label } },
+      rows: {
+        type: "array",
+        maxItems: L.rows,
+        items: {
+          type: "object",
+          required: ["label", "cells"],
+          additionalProperties: false,
+          properties: {
+            label: { type: "string", maxLength: L.label },
+            sub: { type: "string", maxLength: L.label },
+            cells: {
+              type: "array",
+              maxItems: L.columns,
+              items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  value: { type: ["string", "number"], maxLength: L.cellText },
+                  sub: { type: "string", maxLength: L.cellText },
+                  state: { enum: [...TABLE_CELL_STATES] }
+                }
+              }
+            }
+          }
         }
-        if (result instanceof Promise) {
-          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+      },
+      legend: {
+        type: "array",
+        maxItems: TABLE_CELL_STATES.length,
+        items: {
+          type: "object",
+          required: ["state", "label"],
+          additionalProperties: false,
+          properties: {
+            state: { enum: [...TABLE_CELL_STATES] },
+            label: { type: "string", maxLength: L.label }
+          }
         }
-        return acc;
-      };
-      if (ctx.common.async === false) {
-        const inner = this._def.schema._parseSync({
-          data: ctx.data,
-          path: ctx.path,
-          parent: ctx
-        });
-        if (inner.status === "aborted")
-          return INVALID;
-        if (inner.status === "dirty")
-          status.dirty();
-        executeRefinement(inner.value);
-        return { status: status.value, value: inner.value };
-      } else {
-        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
-          if (inner.status === "aborted")
-            return INVALID;
-          if (inner.status === "dirty")
-            status.dirty();
-          return executeRefinement(inner.value).then(() => {
-            return { status: status.value, value: inner.value };
-          });
-        });
       }
     }
-    if (effect.type === "transform") {
-      if (ctx.common.async === false) {
-        const base = this._def.schema._parseSync({
-          data: ctx.data,
-          path: ctx.path,
-          parent: ctx
-        });
-        if (!isValid(base))
-          return INVALID;
-        const result = effect.transform(base.value, checkCtx);
-        if (result instanceof Promise) {
-          throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
-        }
-        return { status: status.value, value: result };
-      } else {
-        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
-          if (!isValid(base))
-            return INVALID;
-          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
-            status: status.value,
-            value: result
-          }));
-        });
-      }
+  };
+}
+var DASHBOARD_WIDGET_SCHEMAS = {
+  kpi: {
+    type: "object",
+    required: ["value"],
+    additionalProperties: false,
+    properties: {
+      label: { type: "string" },
+      value: { type: ["string", "number"] },
+      delta: { type: "string" },
+      deltaTone: { enum: ["positive", "negative", "neutral"] },
+      values: { type: "array", items: { type: "number" } },
+      color: { type: "string", pattern: "^#[0-9a-fA-F]{6}$" }
     }
-    util.assertNever(effect);
-  }
-};
-ZodEffects.create = (schema, effect, params) => {
-  return new ZodEffects({
-    schema,
-    typeName: ZodFirstPartyTypeKind.ZodEffects,
-    effect,
-    ...processCreateParams(params)
-  });
-};
-ZodEffects.createWithPreprocess = (preprocess2, schema, params) => {
-  return new ZodEffects({
-    schema,
-    effect: { type: "preprocess", transform: preprocess2 },
-    typeName: ZodFirstPartyTypeKind.ZodEffects,
-    ...processCreateParams(params)
-  });
-};
-var ZodOptional = class extends ZodType {
-  _parse(input) {
-    const parsedType2 = this._getType(input);
-    if (parsedType2 === ZodParsedType.undefined) {
-      return OK(void 0);
+  },
+  area: categoriesSeriesSchema(),
+  line: categoriesSeriesSchema(),
+  bar: categoriesSeriesSchema(),
+  donut: {
+    type: "object",
+    required: ["labels", "series"],
+    additionalProperties: false,
+    properties: {
+      labels: { type: "array", items: { type: "string" } },
+      series: { type: "array", items: { type: "number" } }
     }
-    return this._def.innerType._parse(input);
+  },
+  table: tableSchema()
+};
+
+// ../core/dist/dashboards/y-axis-hints.js
+var Y_AXIS_WIDGET_KINDS = ["area", "line", "bar"];
+var Y_AXIS_MAX_TICKS = 21;
+
+// src/dashboard-widget-def-schema.ts
+var WidgetDefSchema = external_exports.object({
+  id: external_exports.string().describe("Stable id within the dashboard, e.g. 'kpi.revenue' or 'chart.cashflow'."),
+  kind: external_exports.enum(DASHBOARD_WIDGET_KINDS).describe(
+    `Widget kind. The kind picks both the renderer AND the data shape your refresh must produce:
+  kpi   \u2192 { value, [delta], [deltaTone: positive|negative|neutral], [values: number[]], [color: '#rrggbb'], [label] }
+  area  \u2192 { categories: string[], series: [{ name, data: number[] }] }
+  line  \u2192 { categories: string[], series: [{ name, data: number[] }] }
+  bar   \u2192 { categories: string[], series: [{ name, data: number[] }] }
+  donut \u2192 { labels: string[], series: number[] }
+  table \u2192 { [rowHeader], columns: string[], rows: [{ label, [sub], cells: [{ [value], [sub], [state] }] }], [legend: [{ state, label }]] }
+          Exactly one cell per column in every row. state (${TABLE_CELL_STATES.join("|")}) colours the cell. For a grid coloured by category (e.g. work type), map each category to a state and name it in legend.`
+  ),
+  title: external_exports.string().optional().describe("Title shown above the widget."),
+  prompt: external_exports.string().describe("What future-you reads on every refresh. Tight, specific \u2014 e.g. 'Total Xero revenue last 30 days. value as $N,NNN AUD (whole dollars \u2014 no cents on dashboards), delta vs prior 30d, values = daily revenue.'"),
+  refresh_cron: external_exports.string().optional().describe('Optional per-widget cron override (e.g. "0 6 * * *" for 6am daily).'),
+  // CS-1708: without this key z.object strips y_axis, and the hint never reaches the host.
+  y_axis: external_exports.object({
+    min: external_exports.number().optional(),
+    max: external_exports.number().optional(),
+    step: external_exports.number().optional(),
+    integer: external_exports.boolean().optional()
+  }).strict().optional().describe(
+    `Optional, for ${Y_AXIS_WIDGET_KINDS.join(", ")} widgets: fix the y axis when the chart counts whole units or has a hard limit. e.g. { min: 0, max: 7, step: 1, integer: true } for days in a week. step must divide max - min (min defaults to 0), with at most ${Y_AXIS_MAX_TICKS} ticks. integer: true on its own gives whole-number ticks sized to the data. Refused on kpi, donut and table widgets.`
+  )
+});
+
+// src/kanban-get-error.ts
+function kanbanGetErrorMessage(status, id, fallbackMessage) {
+  if (status === 400) return "A card id is required.";
+  if (status === 404) return `No card with id "${id}" on your board.`;
+  return `Could not read the card: ${fallbackMessage}`;
+}
+
+// src/knowledge-body-render.ts
+function renderKnowledgeBody(content) {
+  if (content === void 0 || content === null) {
+    return "(!) CONTRACT FAILURE: the API returned no `content` field for this entry. This is NOT an empty entry \u2014 the body was not delivered. Do not treat this as the entry text, and do not knowledge_update from it: an update replaces the whole body and would erase the real one. Report this as a bug.";
   }
-  unwrap() {
-    return this._def.innerType;
+  if (content.length === 0) {
+    return "(empty \u2014 this entry genuinely has no body text)";
   }
-};
-ZodOptional.create = (type, params) => {
-  return new ZodOptional({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodOptional,
-    ...processCreateParams(params)
-  });
-};
-var ZodNullable = class extends ZodType {
-  _parse(input) {
-    const parsedType2 = this._getType(input);
-    if (parsedType2 === ZodParsedType.null) {
-      return OK(null);
+  return content;
+}
+
+// src/index.ts
+import { homedir as homedir3 } from "os";
+import { basename, isAbsolute as isAbsolute2, join as join6, resolve as pathResolve, sep as sep2 } from "path";
+
+// src/host-file-path.ts
+var SKILL_BODY_PATH_MAX_BYTES = 512 * 1024;
+var AGT_LIVE_CONTENT_PATH_MAX_BYTES = 2 * 1024 * 1024;
+var HOST_FILE_PATH_TOOLS = /* @__PURE__ */ new Map([
+  [
+    "skill_create",
+    { pathArg: "body_path", targetArg: "body", maxBytes: SKILL_BODY_PATH_MAX_BYTES, label: "a skill body" }
+  ],
+  [
+    "skill_update",
+    { pathArg: "body_path", targetArg: "body", maxBytes: SKILL_BODY_PATH_MAX_BYTES, label: "a skill body" }
+  ],
+  [
+    "agt_live_publish",
+    {
+      pathArg: "content_path",
+      targetArg: "content",
+      maxBytes: AGT_LIVE_CONTENT_PATH_MAX_BYTES,
+      label: "a published page"
     }
-    return this._def.innerType._parse(input);
+  ]
+]);
+function hostFilePathArg(toolName) {
+  return HOST_FILE_PATH_TOOLS.get(toolName)?.pathArg;
+}
+function allowedHostFileRoots(agentDir, path) {
+  return [path.join(agentDir, "project"), path.join(agentDir, "scratch")];
+}
+function openContained(target, roots, opts) {
+  const { path, fs, procFdBase } = opts;
+  if (!procFdBase) {
+    return {
+      ok: false,
+      error: "reading a host path needs descriptor-relative traversal (procfs), which this platform does not provide. Pass the content inline instead."
+    };
   }
-  unwrap() {
-    return this._def.innerType;
+  const root = roots.find((r) => isContained(target, r, path.sep));
+  if (!root) return { ok: false, error: "resolved outside the allowed roots" };
+  const segments = target.slice(root.length).split(path.sep).filter(Boolean);
+  const fileName = segments[segments.length - 1];
+  if (fileName === void 0) {
+    return { ok: false, error: `'${target}' is a directory, not a file` };
   }
-};
-ZodNullable.create = (type, params) => {
-  return new ZodNullable({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodNullable,
-    ...processCreateParams(params)
-  });
-};
-var ZodDefault = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    let data = ctx.data;
-    if (ctx.parsedType === ZodParsedType.undefined) {
-      data = this._def.defaultValue();
+  for (const segment of segments) {
+    if (segment === "." || segment === "..") {
+      return { ok: false, error: `'${target}' contains a '${segment}' component` };
     }
-    return this._def.innerType._parse({
-      data,
-      path: ctx.path,
-      parent: ctx
-    });
   }
-  removeDefault() {
-    return this._def.innerType;
+  const dirNames = segments.slice(0, -1);
+  let dirFd;
+  try {
+    dirFd = fs.openSync(root, opts.dirOpenFlags);
+  } catch (err) {
+    return { ok: false, error: `the allowed root '${root}' could not be opened \u2014 ${err.message}` };
   }
-};
-ZodDefault.create = (type, params) => {
-  return new ZodDefault({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodDefault,
-    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
-    ...processCreateParams(params)
-  });
-};
-var ZodCatch = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    const newCtx = {
-      ...ctx,
-      common: {
-        ...ctx.common,
-        issues: []
-      }
-    };
-    const result = this._def.innerType._parse({
-      data: newCtx.data,
-      path: newCtx.path,
-      parent: {
-        ...newCtx
-      }
-    });
-    if (isAsync(result)) {
-      return result.then((result2) => {
+  try {
+    for (const name of dirNames) {
+      let nextFd;
+      try {
+        nextFd = fs.openSync(path.join(procFdBase, String(dirFd), name), opts.dirOpenFlags);
+      } catch (err) {
         return {
-          status: "valid",
-          value: result2.status === "valid" ? result2.value : this._def.catchValue({
-            get error() {
-              return new ZodError(newCtx.common.issues);
-            },
-            input: newCtx.data
-          })
+          ok: false,
+          error: `'${name}' could not be entered \u2014 it is a symlink, is not a directory, or was replaced mid-traversal (${err.message})`
         };
-      });
-    } else {
+      }
+      try {
+        fs.closeSync(dirFd);
+      } catch {
+      }
+      dirFd = nextFd;
+    }
+    let fd;
+    try {
+      fd = fs.openSync(path.join(procFdBase, String(dirFd), fileName), opts.openFlags);
+    } catch (err) {
       return {
-        status: "valid",
-        value: result.status === "valid" ? result.value : this._def.catchValue({
-          get error() {
-            return new ZodError(newCtx.common.issues);
-          },
-          input: newCtx.data
-        })
+        ok: false,
+        error: `'${fileName}' could not be opened (a symlink, or replaced mid-check) \u2014 ${err.message}`
       };
     }
+    return { ok: true, fd };
+  } finally {
+    try {
+      fs.closeSync(dirFd);
+    } catch {
+    }
   }
-  removeCatch() {
-    return this._def.innerType;
+}
+function isContained(candidate, root, sep3) {
+  if (candidate === root) return true;
+  const rootWithSep = root.endsWith(sep3) ? root : root + sep3;
+  return candidate.startsWith(rootWithSep);
+}
+function resolveHostFilePath(toolName, args, opts) {
+  const spec = HOST_FILE_PATH_TOOLS.get(toolName);
+  if (!spec) return { ok: true, args };
+  const raw = args[spec.pathArg];
+  if (raw === void 0 || raw === null) return { ok: true, args };
+  if (typeof raw !== "string" || raw.trim() === "") {
+    return { ok: false, error: `${spec.pathArg} must be a non-empty string.` };
   }
-};
-ZodCatch.create = (type, params) => {
-  return new ZodCatch({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodCatch,
-    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
-    ...processCreateParams(params)
-  });
-};
-var ZodNaN = class extends ZodType {
-  _parse(input) {
-    const parsedType2 = this._getType(input);
-    if (parsedType2 !== ZodParsedType.nan) {
-      const ctx = this._getOrReturnCtx(input);
-      addIssueToContext(ctx, {
-        code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.nan,
-        received: ctx.parsedType
-      });
-      return INVALID;
-    }
-    return { status: "valid", value: input.data };
+  if (typeof args[spec.targetArg] === "string") {
+    return {
+      ok: false,
+      error: `Pass either ${spec.targetArg} or ${spec.pathArg}, not both \u2014 they are two ways to say the same thing and I will not guess which one you meant.`
+    };
   }
-};
-ZodNaN.create = (params) => {
-  return new ZodNaN({
-    typeName: ZodFirstPartyTypeKind.ZodNaN,
-    ...processCreateParams(params)
-  });
-};
-var BRAND = /* @__PURE__ */ Symbol("zod_brand");
-var ZodBranded = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    const data = ctx.data;
-    return this._def.type._parse({
-      data,
-      path: ctx.path,
-      parent: ctx
-    });
+  const { agentDir, path, fs } = opts;
+  const maxBytes = opts.maxBytes ?? spec.maxBytes;
+  const roots = allowedHostFileRoots(agentDir, path);
+  const absolute = path.isAbsolute(raw) ? path.resolve(raw) : path.resolve(path.join(agentDir, "project"), raw);
+  if (!roots.some((r) => isContained(absolute, r, path.sep))) {
+    return {
+      ok: false,
+      error: `${spec.pathArg} must be inside your own project or scratch directory. Got '${raw}'. Allowed: ${roots.join(", ")}`
+    };
   }
-  unwrap() {
-    return this._def.type;
+  let real;
+  try {
+    real = fs.realpathSync(absolute);
+  } catch {
+    return { ok: false, error: `${spec.pathArg} does not exist or is unreadable: '${raw}'` };
   }
-};
-var ZodPipeline = class _ZodPipeline extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
-    if (ctx.common.async) {
-      const handleAsync = async () => {
-        const inResult = await this._def.in._parseAsync({
-          data: ctx.data,
-          path: ctx.path,
-          parent: ctx
-        });
-        if (inResult.status === "aborted")
-          return INVALID;
-        if (inResult.status === "dirty") {
-          status.dirty();
-          return DIRTY(inResult.value);
-        } else {
-          return this._def.out._parseAsync({
-            data: inResult.value,
-            path: ctx.path,
-            parent: ctx
-          });
-        }
-      };
-      return handleAsync();
-    } else {
-      const inResult = this._def.in._parseSync({
-        data: ctx.data,
-        path: ctx.path,
-        parent: ctx
-      });
-      if (inResult.status === "aborted")
-        return INVALID;
-      if (inResult.status === "dirty") {
-        status.dirty();
-        return {
-          status: "dirty",
-          value: inResult.value
-        };
-      } else {
-        return this._def.out._parseSync({
-          data: inResult.value,
-          path: ctx.path,
-          parent: ctx
-        });
-      }
+  if (!roots.some((r) => isContained(real, r, path.sep))) {
+    return {
+      ok: false,
+      error: `${spec.pathArg} resolves outside your own directories (symlink?). '${raw}' \u2192 '${real}'. Allowed: ${roots.join(", ")}`
+    };
+  }
+  const opened = openContained(real, roots, opts);
+  if (!opened.ok) return { ok: false, error: `${spec.pathArg}: ${opened.error} ('${raw}')` };
+  const fd = opened.fd;
+  try {
+    let stat;
+    try {
+      stat = fs.fstatSync(fd);
+    } catch {
+      return { ok: false, error: `${spec.pathArg} could not be inspected: '${raw}'` };
+    }
+    if (!stat.isFile()) {
+      return { ok: false, error: `${spec.pathArg} is not a regular file: '${raw}'` };
+    }
+    if (stat.size > maxBytes) {
+      return {
+        ok: false,
+        error: `${spec.pathArg} is ${stat.size} bytes, over the ${maxBytes}-byte limit for ${spec.label}.`
+      };
+    }
+    let bytes;
+    try {
+      bytes = fs.readFdSync(fd, maxBytes);
+    } catch (err) {
+      return { ok: false, error: `${spec.pathArg} could not be read: ${err.message}` };
+    }
+    if (bytes.byteLength > maxBytes) {
+      return { ok: false, error: `${spec.pathArg} grew past the ${maxBytes}-byte limit while being read.` };
+    }
+    const value = fs.decodeUtf8(bytes);
+    const next = { ...args, [spec.targetArg]: value };
+    delete next[spec.pathArg];
+    return { ok: true, args: next };
+  } finally {
+    try {
+      fs.closeSync(fd);
+    } catch {
     }
   }
-  static create(a, b) {
-    return new _ZodPipeline({
-      in: a,
-      out: b,
-      typeName: ZodFirstPartyTypeKind.ZodPipeline
-    });
+}
+
+// src/artefact-work-dir.ts
+import { mkdir, mkdtemp } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, join as join2 } from "path";
+
+// ../core/dist/provisioning/frameworks/claudecode/agent-dir-alias.js
+import { isAbsolute, join, relative, sep } from "path";
+var VALID_CODE_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var VALID_AGENT_ID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+var INITIATOR_BASENAME = ".current-turn-initiator.json";
+function isSafeAgentSegment(segment) {
+  return VALID_CODE_NAME.test(segment) || VALID_AGENT_ID.test(segment);
+}
+function initiatorDirSegment(initiatorFile, homeDir) {
+  const rel = relative(join(homeDir, ".augmented"), initiatorFile);
+  if (!rel || isAbsolute(rel))
+    return null;
+  const parts = rel.split(sep);
+  if (parts.length !== 2 || parts[1] !== INITIATOR_BASENAME)
+    return null;
+  const segment = parts[0];
+  if (segment === void 0)
+    return null;
+  return isSafeAgentSegment(segment) ? segment : null;
+}
+function resolveAgentDirAlias(input) {
+  const { codeName, turnInitiatorFile, agentId, homeDir } = input;
+  const codeNameTrimmed = typeof codeName === "string" ? codeName.trim() : "";
+  if (codeNameTrimmed && VALID_CODE_NAME.test(codeNameTrimmed)) {
+    return join(homeDir, ".augmented", codeNameTrimmed);
   }
-};
-var ZodReadonly = class extends ZodType {
-  _parse(input) {
-    const result = this._def.innerType._parse(input);
-    const freeze = (data) => {
-      if (isValid(data)) {
-        data.value = Object.freeze(data.value);
-      }
-      return data;
-    };
-    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+  const initiator = typeof turnInitiatorFile === "string" ? turnInitiatorFile.trim() : "";
+  if (initiator) {
+    const segment = initiatorDirSegment(initiator, homeDir);
+    if (segment)
+      return join(homeDir, ".augmented", segment);
   }
-  unwrap() {
-    return this._def.innerType;
+  const agentIdTrimmed = typeof agentId === "string" ? agentId.trim() : "";
+  if (agentIdTrimmed && VALID_AGENT_ID.test(agentIdTrimmed)) {
+    return join(homeDir, ".augmented", agentIdTrimmed);
   }
-};
-ZodReadonly.create = (type, params) => {
-  return new ZodReadonly({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodReadonly,
-    ...processCreateParams(params)
-  });
-};
-function cleanParams(params, data) {
-  const p2 = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
-  const p22 = typeof p2 === "string" ? { message: p2 } : p2;
-  return p22;
+  return null;
 }
-function custom(check2, _params = {}, fatal) {
-  if (check2)
-    return ZodAny.create().superRefine((data, ctx) => {
-      const r = check2(data);
-      if (r instanceof Promise) {
-        return r.then((r2) => {
-          if (!r2) {
-            const params = cleanParams(_params, data);
-            const _fatal = params.fatal ?? fatal ?? true;
-            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-          }
-        });
-      }
-      if (!r) {
-        const params = cleanParams(_params, data);
-        const _fatal = params.fatal ?? fatal ?? true;
-        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-      }
-      return;
-    });
-  return ZodAny.create();
+function resolveAgentScratchDir(input) {
+  const alias = resolveAgentDirAlias(input);
+  return alias === null ? null : join(alias, "scratch");
+}
+
+// src/artefact-work-dir.ts
+async function makeArtefactWorkDir(prefix, env2) {
+  const scratch = resolveAgentScratchDir(env2);
+  if (scratch === null) {
+    throw new Error(
+      "Cannot save the artefact: none of AGT_AGENT_CODE_NAME, AGT_TURN_INITIATOR_FILE or AGT_AGENT_ID is set, so this server cannot tell which agent directory the file belongs in."
+    );
+  }
+  const agentDir = dirname(scratch);
+  if (!existsSync(agentDir)) {
+    throw new Error(
+      `Cannot save the artefact: the agent directory ${agentDir} does not exist on this host.`
+    );
+  }
+  await mkdir(scratch, { recursive: true });
+  return mkdtemp(join2(scratch, prefix));
 }
-var late = {
-  object: ZodObject.lazycreate
-};
-var ZodFirstPartyTypeKind;
-(function(ZodFirstPartyTypeKind2) {
-  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
-  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
-  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
-  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
-  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
-  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
-  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
-  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
-  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
-  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
-  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
-  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
-  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
-  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
-  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
-  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
-  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
-  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
-  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
-  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
-  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
-  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
-  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
-  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
-  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
-  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
-  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
-  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
-  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
-  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
-  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
-  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
-  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
-  ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
-  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
-  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
-})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-var instanceOfType = (cls, params = {
-  message: `Input not instance of ${cls.name}`
-}) => custom((data) => data instanceof cls, params);
-var stringType = ZodString.create;
-var numberType = ZodNumber.create;
-var nanType = ZodNaN.create;
-var bigIntType = ZodBigInt.create;
-var booleanType = ZodBoolean.create;
-var dateType = ZodDate.create;
-var symbolType = ZodSymbol.create;
-var undefinedType = ZodUndefined.create;
-var nullType = ZodNull.create;
-var anyType = ZodAny.create;
-var unknownType = ZodUnknown.create;
-var neverType = ZodNever.create;
-var voidType = ZodVoid.create;
-var arrayType = ZodArray.create;
-var objectType = ZodObject.create;
-var strictObjectType = ZodObject.strictCreate;
-var unionType = ZodUnion.create;
-var discriminatedUnionType = ZodDiscriminatedUnion.create;
-var intersectionType = ZodIntersection.create;
-var tupleType = ZodTuple.create;
-var recordType = ZodRecord.create;
-var mapType = ZodMap.create;
-var setType = ZodSet.create;
-var functionType = ZodFunction.create;
-var lazyType = ZodLazy.create;
-var literalType = ZodLiteral.create;
-var enumType = ZodEnum.create;
-var nativeEnumType = ZodNativeEnum.create;
-var promiseType = ZodPromise.create;
-var effectsType = ZodEffects.create;
-var optionalType = ZodOptional.create;
-var nullableType = ZodNullable.create;
-var preprocessType = ZodEffects.createWithPreprocess;
-var pipelineType = ZodPipeline.create;
-var ostring = () => stringType().optional();
-var onumber = () => numberType().optional();
-var oboolean = () => booleanType().optional();
-var coerce = {
-  string: ((arg) => ZodString.create({ ...arg, coerce: true })),
-  number: ((arg) => ZodNumber.create({ ...arg, coerce: true })),
-  boolean: ((arg) => ZodBoolean.create({
-    ...arg,
-    coerce: true
-  })),
-  bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })),
-  date: ((arg) => ZodDate.create({ ...arg, coerce: true }))
-};
-var NEVER = INVALID;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/core.js
 var NEVER2 = Object.freeze({
@@ -48807,22 +48862,6 @@ server.tool(
     return { content: [{ type: "text", text: lines.join("\n") }] };
   }
 );
-var WidgetDefSchema = external_exports.object({
-  id: external_exports.string().describe("Stable id within the dashboard, e.g. 'kpi.revenue' or 'chart.cashflow'."),
-  kind: external_exports.enum(DASHBOARD_WIDGET_KINDS).describe(
-    `Widget kind. The kind picks both the renderer AND the data shape your refresh must produce:
-  kpi   \u2192 { value, [delta], [deltaTone: positive|negative|neutral], [values: number[]], [color: '#rrggbb'], [label] }
-  area  \u2192 { categories: string[], series: [{ name, data: number[] }] }
-  line  \u2192 { categories: string[], series: [{ name, data: number[] }] }
-  bar   \u2192 { categories: string[], series: [{ name, data: number[] }] }
-  donut \u2192 { labels: string[], series: number[] }
-  table \u2192 { [rowHeader], columns: string[], rows: [{ label, [sub], cells: [{ [value], [sub], [state] }] }], [legend: [{ state, label }]] }
-          Exactly one cell per column in every row. state (${TABLE_CELL_STATES.join("|")}) colours the cell. For a grid coloured by category (e.g. work type), map each category to a state and name it in legend.`
-  ),
-  title: external_exports.string().optional().describe("Title shown above the widget."),
-  prompt: external_exports.string().describe("What future-you reads on every refresh. Tight, specific \u2014 e.g. 'Total Xero revenue last 30 days. value as $N,NNN AUD (whole dollars \u2014 no cents on dashboards), delta vs prior 30d, values = daily revenue.'"),
-  refresh_cron: external_exports.string().optional().describe('Optional per-widget cron override (e.g. "0 6 * * *" for 6am daily).')
-});
 server.tool(
   "dashboards_list",
   'List dashboards visible to your team. Use to answer "what dashboards exist", "show me the dashboards I built", or before authoring a new one to avoid duplicating an existing slug.',