@integrity-labs/agt-cli 0.28.890 → 0.28.892

package/dist/mcp/index.js

@@ -27363,6 +27363,12 @@ var CURSOR_SHORTFALL_REASONS = [
 var NON_SHORTFALL_KEYS = new Set(CURSOR_ADVANCE_NON_SHORTFALL_KEYS);
 var KNOWN_REASONS = new Set(CURSOR_SHORTFALL_REASONS.filter((k) => !NON_SHORTFALL_KEYS.has(k)));
 
+// ../core/dist/direct-chat/agent-history-notices.js
+var AGENT_HISTORY_TURNS_ONLY_OR_FILTER = [
+  "payload->>kind.is.null",
+  `payload->>kind.in.("",${[...USER_FACING_NOTICE_KINDS].sort().join(",")})`
+].join(",");
+
 // ../core/dist/onboarding/state-machine.js
 var AREA_ORDER = [
   "framing",
@@ -29779,14 +29785,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
   },
   {
@@ -29803,16 +29833,36 @@ var FLAG_REGISTRY = [
   },
   {
     key: "ninjafy-brand",
-    description: 'Present the product under the Ninjafy brand instead of Augmented Team (ENG-8250). This is the UMBRELLA brand gate, not a one-off nav toggle: every subsequent rebrand surface (page titles, email templates, marketing-facing copy) reads THIS key rather than adding its own flag, so the whole rebrand keeps a single kill switch. First surface is the left-hand nav wordmark \u2014 ON replaces the human+robot mark and the "augmented.team" text with italic lowercase "ninjafy"; OFF renders exactly what shipped before. Scope is the USER-FACING BRAND PRESENTATION \u2014 text AND VISUAL THEME. ENG-8858 widened this from text alone: the Ninjafy palette is gated here too, because a colour theme is not text. It stays ONE key rather than gaining a `ninjafy-theme` sibling, so a half-branded state \u2014 ninjafy wordmark over Augmented green \u2014 is unreachable and the rebrand keeps a single kill switch. It must never gate a code identifier, package name, env var or CLI name. EXISTING identifiers stay `Augmented`/`agt` per the CLAUDE.md naming contract, which protects them from premature renaming \u2014 the deep rename is workstream C of docs/runbooks/rebrand-ninjafy-migration.md and is out of scope here. That contract does NOT require NEW code to carry the old brand: artefacts created specifically for the rebrand take Ninjafy naming (ENG-8078 decision 9; see the CLAUDE.md rebrand carve-out). Either way it is a naming rule, not a flag concern \u2014 this key gates presentation, never an identifier. Set the stage-wide default to flip a whole environment, or add a feature_flag_overrides row to pilot a subset while everyone else still sees Augmented. Overrides resolve at FOUR grains, most specific first \u2014 agent, team, host, then org-wide (evaluate.ts:79-81); organization_id is always required, so there is no global override. Org and team are the useful pilot grains for THIS flag: there is now exactly ONE consumer \u2014 (dashboard)/layout.tsx via getPublicBooleanFlagServer \u2014 evaluating in the active-org cookie scope, so a host- or agent-scoped row is accepted by the table but never reached by the console. It resolves the key ONCE per request and passes the boolean down to sidebar.tsx and top-nav.tsx as a required prop. Resolution is SERVER-side deliberately: the client hook starts at its default and updates after an async GET /flags, so anything gated on it paints Augmented and then repaints. ENG-8858 moved the PALETTE for that reason (a full-page colour flash); ENG-9227 moved the WORDMARK, which had been the last surface still swapping after hydration. A consequence worth knowing: /login and the marketing routes stay on the Augmented palette whatever an org sets, because getPublicBooleanFlagServer returns the default without a verified session and a pre-auth page has neither a session nor an active org \u2014 a PER-ORG flag structurally cannot brand one. Those surfaces follow only when the stage-wide default flips. Ships dark.',
+    description: 'Present the product under the Ninjafy brand instead of Augmented Team (ENG-8250). This is the UMBRELLA brand gate, not a one-off nav toggle: every subsequent rebrand surface (page titles, email templates, marketing-facing copy) reads THIS key rather than adding its own flag, so the whole rebrand keeps a single kill switch. First surface is the left-hand nav wordmark \u2014 ON replaces the human+robot mark and the "augmented.team" text with italic lowercase "ninjafy"; OFF renders exactly what shipped before. Scope is the USER-FACING BRAND PRESENTATION \u2014 text AND VISUAL THEME. ENG-8858 widened this from text alone: the Ninjafy palette is gated here too, because a colour theme is not text. It stays ONE key rather than gaining a `ninjafy-theme` sibling, so a half-branded state \u2014 ninjafy wordmark over Augmented green \u2014 is unreachable and the rebrand keeps a single kill switch. It must never gate a code identifier, package name, env var or CLI name. EXISTING identifiers stay `Augmented`/`agt` per the CLAUDE.md naming contract, which protects them from premature renaming \u2014 the deep rename is workstream C of docs/runbooks/rebrand-ninjafy-migration.md and is out of scope here. That contract does NOT require NEW code to carry the old brand: artefacts created specifically for the rebrand take Ninjafy naming (ENG-8078 decision 9; see the CLAUDE.md rebrand carve-out). Either way it is a naming rule, not a flag concern \u2014 this key gates presentation, never an identifier. Set the stage-wide default to flip a whole environment, or add a feature_flag_overrides row to pilot a subset while everyone else still sees Augmented. Overrides resolve at FOUR grains, most specific first \u2014 agent, team, host, then org-wide (evaluate.ts:79-81); organization_id is always required, so there is no global override. Org and team are the useful pilot grains for THIS flag: there is now exactly ONE consumer \u2014 (dashboard)/layout.tsx via getPublicBooleanFlagServer \u2014 evaluating in the active-org cookie scope, so a host- or agent-scoped row is accepted by the table but never reached by the console. It resolves the key ONCE per request and passes the boolean down to sidebar.tsx and top-nav.tsx as a required prop. Resolution is SERVER-side deliberately: the client hook starts at its default and updates after an async GET /flags, so anything gated on it paints Augmented and then repaints. ENG-8858 moved the PALETTE for that reason (a full-page colour flash); ENG-9227 moved the WORDMARK, which had been the last surface still swapping after hydration. A consequence worth knowing: /login and the marketing routes stay on the Augmented palette whatever an org sets, because fetchPublicFlags returns null without a verified session and a pre-auth page has neither a session nor an active org \u2014 a PER-ORG flag structurally cannot brand one. ENG-9830 CORRECTS what used to be written here ("those surfaces follow only when the stage-wide default flips"): they do not follow it at all. Two reasons. The value returned on a null fetch is the CALL SITE\u2019s passed argument, not this registry default; and six such pages (/login, /reset-password, /auth/confirm, the pre-redeem member-signin gate and the two public Slack-install terminal pages) do not mount <BrandStamp/> AT ALL \u2014 deliberately, enumerated with per-page reasons in eng-9266-brand-stamp-coverage.test.ts. They become branded when the flag is REMOVED at cutover step 2 and the palette moves into bare :root, with no read left to gate it. NO LONGER DARK: ENG-9830 cutover step 1 flipped the default to true, so an org with no override now sees Ninjafy. The key survives only until cutover step 2 deletes it.',
     flagType: "boolean",
-    // Declared safe value is `false`: the pre-rebrand brand. `false` is also the
-    // fail-closed direction — if the flag DB is unreachable we must show the brand
-    // that is currently live and contractually correct, never leak an unannounced
-    // rebrand to every customer at once.
-    defaultValue: false,
+    // ENG-9830 (cutover step 1): flipped `false` -> `true`. The comment this
+    // replaces argued `false` was the fail-closed direction — "never leak an
+    // UNANNOUNCED rebrand to every customer at once". That was correct for as
+    // long as the rebrand was unannounced. It is not any more: Ninjafy is the
+    // live, announced brand (ENG-9613 reconciled the console onto the master
+    // assets while the flag was already ON in production), so `false` now points
+    // at the brand we no longer ship. A flags outage that reverted a customer to
+    // Augmented would be the incident, not the safe harbour.
+    //
+    // The old rationale is recorded rather than deleted because it is a correct
+    // argument whose PREMISE expired — reading the change without it looks like
+    // someone overriding a deliberate fail-closed default.
+    //
+    // NOTE this value is only consulted by the API evaluator when building the
+    // `GET /flags` map for an org with no override. It is NOT the fallback the
+    // webapp uses on an outage: `getPublicBooleanFlagServer(key, defaultValue)`
+    // returns its own PASSED argument when the fetch fails, so the call sites in
+    // (dashboard)/layout.tsx and components/brand-stamp.tsx carry `true` too.
+    // Flipping only one of the two leaves the cutover half-applied.
+    defaultValue: true,
     // ENG-9227: there are NO client readers of this key left. (dashboard)/
     // layout.tsx resolves it ONCE server-side via getPublicBooleanFlagServer and
     // passes the boolean down to sidebar.tsx and top-nav.tsx as a required prop.
+    // "ONCE" is about the chrome, not the key: components/brand-stamp.tsx is a
+    // SECOND, independent server read of `ninjafy-brand` (CodeRabbit, #5385).
+    // Both are listed in the note above because both carry an outage fallback
+    // that has to move together — reading this paragraph alone would leave you
+    // updating one of the two.
     // ENG-8858 did that for the THEME; ENG-9227 finished the job for the
     // WORDMARK, which had kept usePublicBooleanFlag and so kept swapping
     // "augmented.team" to "ninjafy" after hydration.
@@ -29834,24 +29884,38 @@ var FLAG_REGISTRY = [
   },
   {
     key: "ninjafy-logo",
-    description: "Which Ninjafy logo TREATMENT the console chrome renders (ENG-9365). This is a SUB-SELECTION under ninjafy-brand, not a second brand gate: it is consulted only once ninjafy-brand has already resolved ON, so with the brand off the value is inert and the half-branded state that flag's description calls unreachable stays unreachable. ninjafy-brand remains the single kill switch for the rebrand. It exists so candidate logo treatments can be put in front of a human and compared in the running console, rather than judged from a static export. lockup = mark and wordmark together, both in the brand blue \u2014 exactly what ENG-9298 shipped, so an unset flag is a no-op. two-tone = the mark in brand blue with the wordmark in the neutral text colour (the treatment of the blue-icon/black-wordmark artwork). wordmark = the word alone, no mark. Every treatment is composed from the ENG-9298 geometry \u2014 ENG-9312 pins that the lockup's blue path IS the mark subpath followed by the wordmark subpaths, byte for byte \u2014 so a new treatment is a composition, never a fresh trace, and the three drawings cannot drift apart. Surfaces are the dashboard sidebar and the top nav. The top nav shows the WORDMARK portion at every width whatever the treatment, because ENG-9342 decided that deliberately (a full lockup at the header's icon height crowds the team switcher on a phone) \u2014 so a treatment changes the word's colour there, never whether a mark appears. The admin sidebar (ENG-9323) is NOT wired to this key and always renders the mark; widening it is a separate decision. Resolved SERVER-SIDE in (dashboard)/layout.tsx via getPublicEnumFlagServer, beside ninjafy-brand and in the same single GET /flags round trip, then passed down as a required prop. That is not a style preference: the client hook starts at its default and updates after an async fetch, so a client read would paint one logo and swap it after hydration \u2014 the exact flash ENG-9227 removed from the wordmark and ENG-8858 removed from the palette. Org and team are the useful pilot grains, as for ninjafy-brand: the single consumer evaluates in the active-org cookie scope, so a host- or agent-scoped override row is accepted by the table but never reached by the console.",
+    description: "Which Ninjafy logo TREATMENT the console chrome renders (ENG-9365). This is a SUB-SELECTION under ninjafy-brand, not a second brand gate: it is consulted only once ninjafy-brand has already resolved ON, so with the brand off the value is inert and the half-branded state that flag's description calls unreachable stays unreachable. ninjafy-brand remains the single kill switch for the rebrand. It existed so candidate logo treatments could be put in front of a human and compared in the running console, rather than judged from a static export. That comparison has happened: ENG-9830 cutover step 1 chose TWO-TONE, so that is now the default and an unset flag renders it. NOTE this reverses the property this description used to claim \u2014 an unset flag was a no-op while the default was lockup (what ENG-9298 shipped), and that is deliberately given up at cutover: the default MOVING is the change. The key survives only until cutover step 2 hardcodes the chosen treatment and deletes it. lockup = mark and wordmark together, both in the brand blue \u2014 what ENG-9298 shipped. two-tone = the mark in brand blue with the wordmark in the neutral text colour (the treatment of the blue-icon/black-wordmark artwork); the chosen one. wordmark = the word alone, no mark. Every treatment is composed from the ENG-9298 geometry \u2014 ENG-9312 pins that the lockup's blue path IS the mark subpath followed by the wordmark subpaths, byte for byte \u2014 so a new treatment is a composition, never a fresh trace, and the three drawings cannot drift apart. Surfaces are the dashboard sidebar and the top nav. The top nav shows the WORDMARK portion at every width whatever the treatment, because ENG-9342 decided that deliberately (a full lockup at the header's icon height crowds the team switcher on a phone) \u2014 so a treatment changes the word's colour there, never whether a mark appears. The admin sidebar (ENG-9323) is NOT wired to this key and always renders the mark; widening it is a separate decision. Resolved SERVER-SIDE in (dashboard)/layout.tsx via getPublicEnumFlagServer, beside ninjafy-brand and in the same single GET /flags round trip, then passed down as a required prop. That is not a style preference: the client hook starts at its default and updates after an async fetch, so a client read would paint one logo and swap it after hydration \u2014 the exact flash ENG-9227 removed from the wordmark and ENG-8858 removed from the palette. Org and team are the useful pilot grains, as for ninjafy-brand: the single consumer evaluates in the active-org cookie scope, so a host- or agent-scoped override row is accepted by the table but never reached by the console.",
     flagType: "enum",
     allowedValues: ["lockup", "two-tone", "wordmark"],
-    // Declared safe value is `lockup` — what ENG-9298 shipped. This flag has no
-    // "off" direction: it selects among presentations that are all live-safe, so
-    // fail-safe here means "the treatment currently in production", not the
+    // ENG-9830 (cutover step 1): `lockup` -> `two-tone`. The treatments existed
+    // so they could be compared in the running console rather than judged from a
+    // static export (ENG-9365); that comparison has now happened and `two-tone`
+    // — the mark in brand blue with the wordmark in the neutral text colour — is
+    // the chosen treatment. It becomes the hardcoded one when this key is
+    // removed at cutover step 2.
+    //
+    // The rule this value obeys is unchanged: this flag has no "off" direction,
+    // so fail-safe means "the treatment currently in production", not the
     // narrowest one. A flag-DB read error, an archived row, or a stored value
     // outside allowedValues all resolve here (evaluate.ts normalizeFlagValue),
-    // which is what makes an experimental value impossible to strand.
-    defaultValue: "lockup",
+    // which is what makes an experimental value impossible to strand. Only which
+    // treatment holds that position has moved.
+    //
+    // Same split as ninjafy-brand above: this governs the API evaluation path
+    // only. The webapp's outage fallback is the argument passed at the
+    // (dashboard)/layout.tsx call site, which carries 'two-tone' to match.
+    defaultValue: "two-tone",
     // Same trap as ninjafy-brand, and it bites harder here because there are no
     // client readers of this key AT ALL — it is server-resolved by construction.
     // `public` does NOT mean "read by a browser"; it means "readable through the
     // public map". getPublicEnumFlagServer resolves against the same GET /flags
     // endpoint the browser uses, and that route filters to listPublicFlagKeys()
     // (routes/flags.ts). Drop `public` and the key is simply absent from the map,
-    // so the helper falls through to its default and returns `lockup` FOREVER —
-    // the dropdown appearing to do nothing, with no error raised anywhere.
+    // so the helper falls through to the fallback passed at that call site and
+    // returns it FOREVER — the dropdown appearing to do nothing, with no error
+    // raised anywhere. Named as the call site rather than as a literal on
+    // purpose: this comment said `lockup` for exactly as long as `lockup` was
+    // the answer, and ENG-9830 flipping the winner is what made it a lie.
     public: true
   },
   {
@@ -30141,527 +30205,163 @@ 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);
+  };
+  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;
   };
-}
-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}$" }
-    }
-  },
-  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" } }
-    }
-  },
-  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 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"
-    }
-  ]
-]);
-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."
-    };
-  }
-  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})`
-        };
-      }
-      try {
-        fs.closeSync(dirFd);
-      } catch {
-      }
-      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 {
-    }
-  }
-}
-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.` };
-  }
-  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.`
-    };
-  }
-  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(", ")}`
-    };
-  }
-  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;
+  util2.find = (arr, checker) => {
+    for (const item of arr) {
+      if (checker(item))
+        return item;
     }
     return void 0;
   };
@@ -33743,808 +33443,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 +48902,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.',