@scarn/sdk 0.0.0-stage → 0.8.0

package/dist/chunk-3ctaaseb.js

@@ -0,0 +1,1456 @@
+// @bun
+import {
+  makeHandle,
+  stepCall,
+  stepNode
+} from "./chunk-mz53r914.js";
+import {
+  ENV_VAR_NAME_PATTERN,
+  containsInputToken,
+  isReservedEnvVarName
+} from "./chunk-5zsavw98.js";
+import {
+  devcontainerConfigPathSchema
+} from "./chunk-4ggr8af6.js";
+import {
+  DEFAULT_CODE_STEP_RUNTIME_ID,
+  MANAGED_RUNTIME_IDS
+} from "./chunk-k4y5qt4y.js";
+import {
+  repoConfigInputSchema,
+  repoRuntimeMismatch
+} from "./chunk-cdanncng.js";
+import {
+  collectEnvPlaceholderNames,
+  isEnvPlaceholderValue,
+  openCodeMcpLocalConfigSchema,
+  openCodeMcpRefConfigSchema,
+  openCodeMcpRemoteConfigSchema
+} from "./chunk-e1h021kq.js";
+import {
+  stepHealthChecksInputSchema,
+  toolHealthCheckSchema
+} from "./chunk-63f90zky.js";
+import {
+  buildArtifactMarker
+} from "./chunk-ngy1fdcx.js";
+import {
+  ARTIFACT_SCHEMA_KEYWORD
+} from "./chunk-y2pv8d6a.js";
+import {
+  BUILT_IN_ERRORS
+} from "./chunk-dp86pa6m.js";
+import {
+  StepDefinitions,
+  createClient
+} from "./chunk-vfeytkqx.js";
+import {
+  $brand,
+  $input,
+  $output,
+  NEVER,
+  TimePrecision,
+  ZodAny,
+  ZodArray,
+  ZodBase64,
+  ZodBase64URL,
+  ZodBigInt,
+  ZodBigIntFormat,
+  ZodBoolean,
+  ZodCIDRv4,
+  ZodCIDRv6,
+  ZodCUID,
+  ZodCUID2,
+  ZodCatch,
+  ZodCodec,
+  ZodCustom,
+  ZodCustomStringFormat,
+  ZodDate,
+  ZodDefault,
+  ZodDiscriminatedUnion,
+  ZodE164,
+  ZodEmail,
+  ZodEmoji,
+  ZodEnum,
+  ZodError,
+  ZodExactOptional,
+  ZodFile,
+  ZodFirstPartyTypeKind,
+  ZodFunction,
+  ZodGUID,
+  ZodIPv4,
+  ZodIPv6,
+  ZodISODate,
+  ZodISODateTime,
+  ZodISODuration,
+  ZodISOTime,
+  ZodIntersection,
+  ZodIssueCode,
+  ZodJWT,
+  ZodKSUID,
+  ZodLazy,
+  ZodLiteral,
+  ZodMAC,
+  ZodMap,
+  ZodNaN,
+  ZodNanoID,
+  ZodNever,
+  ZodNonOptional,
+  ZodNull,
+  ZodNullable,
+  ZodNumber,
+  ZodNumberFormat,
+  ZodObject,
+  ZodOptional,
+  ZodPipe,
+  ZodPrefault,
+  ZodPreprocess,
+  ZodPromise,
+  ZodReadonly,
+  ZodRealError,
+  ZodRecord,
+  ZodSet,
+  ZodString,
+  ZodStringFormat,
+  ZodSuccess,
+  ZodSymbol,
+  ZodTemplateLiteral,
+  ZodTransform,
+  ZodTuple,
+  ZodType,
+  ZodULID,
+  ZodURL,
+  ZodUUID,
+  ZodUndefined,
+  ZodUnion,
+  ZodUnknown,
+  ZodVoid,
+  ZodXID,
+  ZodXor,
+  _ZodString,
+  _catch,
+  _default,
+  _endsWith,
+  _enum,
+  _function,
+  _gt,
+  _gte,
+  _includes,
+  _instanceof,
+  _length,
+  _lowercase,
+  _lt,
+  _lte,
+  _maxLength,
+  _maxSize,
+  _mime,
+  _minLength,
+  _minSize,
+  _multipleOf,
+  _negative,
+  _nonnegative,
+  _nonpositive,
+  _normalize,
+  _null,
+  _overwrite,
+  _positive,
+  _property,
+  _regex,
+  _size,
+  _slugify,
+  _startsWith,
+  _toLowerCase,
+  _toUpperCase,
+  _trim,
+  _undefined,
+  _uppercase,
+  _void,
+  any,
+  array,
+  base64,
+  base64url,
+  bigint,
+  boolean,
+  check,
+  cidrv4,
+  cidrv6,
+  clone,
+  codec,
+  config,
+  cuid,
+  cuid2,
+  custom,
+  date,
+  decode,
+  decodeAsync,
+  describe,
+  discriminatedUnion,
+  e164,
+  email,
+  emoji,
+  encode,
+  encodeAsync,
+  exactOptional,
+  exports_coerce,
+  exports_core,
+  exports_external,
+  exports_iso,
+  exports_locales,
+  exports_regexes,
+  exports_util,
+  file,
+  flattenError,
+  float32,
+  float64,
+  formatError,
+  fromJSONSchema,
+  getErrorMap,
+  globalRegistry,
+  guid,
+  hash,
+  hex,
+  hostname,
+  httpUrl,
+  int,
+  int32,
+  int64,
+  intersection,
+  invertCodec,
+  ipv4,
+  ipv6,
+  json,
+  jwt,
+  keyof,
+  ksuid,
+  lazy,
+  literal,
+  looseObject,
+  looseRecord,
+  mac,
+  map,
+  meta,
+  nan,
+  nanoid,
+  nativeEnum,
+  never,
+  nonoptional,
+  nullable,
+  nullish,
+  number,
+  object,
+  optional,
+  parse,
+  parseAsync,
+  partialRecord,
+  pipe,
+  prefault,
+  preprocess,
+  prettifyError,
+  promise,
+  readonly,
+  record,
+  refine,
+  registry,
+  safeDecode,
+  safeDecodeAsync,
+  safeEncode,
+  safeEncodeAsync,
+  safeParse,
+  safeParseAsync,
+  set,
+  setErrorMap,
+  strictObject,
+  string,
+  stringFormat,
+  stringbool,
+  success,
+  superRefine,
+  symbol,
+  templateLiteral,
+  toJSONSchema,
+  transform,
+  treeifyError,
+  tuple,
+  uint32,
+  uint64,
+  ulid,
+  union,
+  unknown,
+  url,
+  uuid,
+  uuidv4,
+  uuidv6,
+  uuidv7,
+  xid,
+  xor
+} from "./chunk-skzxcba3.js";
+import {
+  __export
+} from "./chunk-y64skrwp.js";
+
+// src/z.ts
+var exports_z = {};
+__export(exports_z, {
+  $brand: () => $brand,
+  $input: () => $input,
+  $output: () => $output,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBase64: () => ZodBase64,
+  ZodBase64URL: () => ZodBase64URL,
+  ZodBigInt: () => ZodBigInt,
+  ZodBigIntFormat: () => ZodBigIntFormat,
+  ZodBoolean: () => ZodBoolean,
+  ZodCIDRv4: () => ZodCIDRv4,
+  ZodCIDRv6: () => ZodCIDRv6,
+  ZodCUID: () => ZodCUID,
+  ZodCUID2: () => ZodCUID2,
+  ZodCatch: () => ZodCatch,
+  ZodCodec: () => ZodCodec,
+  ZodCustom: () => ZodCustom,
+  ZodCustomStringFormat: () => ZodCustomStringFormat,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodE164: () => ZodE164,
+  ZodEmail: () => ZodEmail,
+  ZodEmoji: () => ZodEmoji,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodExactOptional: () => ZodExactOptional,
+  ZodFile: () => ZodFile,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodGUID: () => ZodGUID,
+  ZodIPv4: () => ZodIPv4,
+  ZodIPv6: () => ZodIPv6,
+  ZodISODate: () => ZodISODate,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodJWT: () => ZodJWT,
+  ZodKSUID: () => ZodKSUID,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMAC: () => ZodMAC,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNanoID: () => ZodNanoID,
+  ZodNever: () => ZodNever,
+  ZodNonOptional: () => ZodNonOptional,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodNumberFormat: () => ZodNumberFormat,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodPipe: () => ZodPipe,
+  ZodPrefault: () => ZodPrefault,
+  ZodPreprocess: () => ZodPreprocess,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRealError: () => ZodRealError,
+  ZodRecord: () => ZodRecord,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodStringFormat: () => ZodStringFormat,
+  ZodSuccess: () => ZodSuccess,
+  ZodSymbol: () => ZodSymbol,
+  ZodTemplateLiteral: () => ZodTemplateLiteral,
+  ZodTransform: () => ZodTransform,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodULID: () => ZodULID,
+  ZodURL: () => ZodURL,
+  ZodUUID: () => ZodUUID,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  ZodXID: () => ZodXID,
+  ZodXor: () => ZodXor,
+  _ZodString: () => _ZodString,
+  _default: () => _default,
+  _function: () => _function,
+  any: () => any,
+  array: () => array,
+  artifact: () => artifact,
+  base64: () => base64,
+  base64url: () => base64url,
+  bigint: () => bigint,
+  boolean: () => boolean,
+  catch: () => _catch,
+  check: () => check,
+  cidrv4: () => cidrv4,
+  cidrv6: () => cidrv6,
+  clone: () => clone,
+  codec: () => codec,
+  coerce: () => exports_coerce,
+  config: () => config,
+  core: () => exports_core,
+  cuid: () => cuid,
+  cuid2: () => cuid2,
+  custom: () => custom,
+  date: () => date,
+  decode: () => decode,
+  decodeAsync: () => decodeAsync,
+  describe: () => describe,
+  discriminatedUnion: () => discriminatedUnion,
+  e164: () => e164,
+  email: () => email,
+  emoji: () => emoji,
+  encode: () => encode,
+  encodeAsync: () => encodeAsync,
+  endsWith: () => _endsWith,
+  enum: () => _enum,
+  exactOptional: () => exactOptional,
+  file: () => file,
+  flattenError: () => flattenError,
+  float32: () => float32,
+  float64: () => float64,
+  formatError: () => formatError,
+  fromJSONSchema: () => fromJSONSchema,
+  function: () => _function,
+  getErrorMap: () => getErrorMap,
+  globalRegistry: () => globalRegistry,
+  gt: () => _gt,
+  gte: () => _gte,
+  guid: () => guid,
+  hash: () => hash,
+  hex: () => hex,
+  hostname: () => hostname,
+  httpUrl: () => httpUrl,
+  includes: () => _includes,
+  instanceof: () => _instanceof,
+  int: () => int,
+  int32: () => int32,
+  int64: () => int64,
+  intersection: () => intersection,
+  invertCodec: () => invertCodec,
+  ipv4: () => ipv4,
+  ipv6: () => ipv6,
+  iso: () => exports_iso,
+  json: () => json,
+  jwt: () => jwt,
+  keyof: () => keyof,
+  ksuid: () => ksuid,
+  lazy: () => lazy,
+  length: () => _length,
+  literal: () => literal,
+  locales: () => exports_locales,
+  looseObject: () => looseObject,
+  looseRecord: () => looseRecord,
+  lowercase: () => _lowercase,
+  lt: () => _lt,
+  lte: () => _lte,
+  mac: () => mac,
+  map: () => map,
+  maxLength: () => _maxLength,
+  maxSize: () => _maxSize,
+  meta: () => meta,
+  mime: () => _mime,
+  minLength: () => _minLength,
+  minSize: () => _minSize,
+  multipleOf: () => _multipleOf,
+  nan: () => nan,
+  nanoid: () => nanoid,
+  nativeEnum: () => nativeEnum,
+  negative: () => _negative,
+  never: () => never,
+  nonnegative: () => _nonnegative,
+  nonoptional: () => nonoptional,
+  nonpositive: () => _nonpositive,
+  normalize: () => _normalize,
+  null: () => _null,
+  nullable: () => nullable,
+  nullish: () => nullish,
+  number: () => number,
+  object: () => object,
+  optional: () => optional,
+  overwrite: () => _overwrite,
+  parse: () => parse,
+  parseAsync: () => parseAsync,
+  partialRecord: () => partialRecord,
+  pipe: () => pipe,
+  positive: () => _positive,
+  prefault: () => prefault,
+  preprocess: () => preprocess,
+  prettifyError: () => prettifyError,
+  promise: () => promise,
+  property: () => _property,
+  readonly: () => readonly,
+  record: () => record,
+  refine: () => refine,
+  regex: () => _regex,
+  regexes: () => exports_regexes,
+  registry: () => registry,
+  safeDecode: () => safeDecode,
+  safeDecodeAsync: () => safeDecodeAsync,
+  safeEncode: () => safeEncode,
+  safeEncodeAsync: () => safeEncodeAsync,
+  safeParse: () => safeParse,
+  safeParseAsync: () => safeParseAsync,
+  set: () => set,
+  setErrorMap: () => setErrorMap,
+  size: () => _size,
+  slugify: () => _slugify,
+  startsWith: () => _startsWith,
+  strictObject: () => strictObject,
+  string: () => string,
+  stringFormat: () => stringFormat,
+  stringbool: () => stringbool,
+  success: () => success,
+  superRefine: () => superRefine,
+  symbol: () => symbol,
+  templateLiteral: () => templateLiteral,
+  toJSONSchema: () => toJSONSchema,
+  toLowerCase: () => _toLowerCase,
+  toUpperCase: () => _toUpperCase,
+  transform: () => transform,
+  treeifyError: () => treeifyError,
+  trim: () => _trim,
+  tuple: () => tuple,
+  uint32: () => uint32,
+  uint64: () => uint64,
+  ulid: () => ulid,
+  undefined: () => _undefined,
+  union: () => union,
+  unknown: () => unknown,
+  uppercase: () => _uppercase,
+  url: () => url,
+  util: () => exports_util,
+  uuid: () => uuid,
+  uuidv4: () => uuidv4,
+  uuidv6: () => uuidv6,
+  uuidv7: () => uuidv7,
+  void: () => _void,
+  xid: () => xid,
+  xor: () => xor,
+  z: () => exports_external
+});
+
+// src/definitions/artifacts/artifact.ts
+var ARTIFACT_BRAND = "ScarnArtifact";
+var ArtifactTypes = {
+  video: [".mp4", ".webm", ".mov"],
+  image: [".png", ".jpg", ".jpeg", ".gif", ".svg"]
+};
+var EXTENSION_PATTERN = /^\.[a-z0-9][a-z0-9_-]*(\.[a-z0-9][a-z0-9_-]*)*$/;
+function describeEntry(entry) {
+  const cleaned = entry.trim().toLowerCase().replace(/^\*?\.?/, "");
+  return cleaned && EXTENSION_PATTERN.test(`.${cleaned}`) ? ` Did you mean \`.${cleaned}\`?` : "";
+}
+function normalizeArtifactAccept(accept) {
+  if (accept === undefined)
+    return [];
+  const problems = [];
+  const out = [];
+  for (const entry of accept) {
+    if (typeof entry !== "string") {
+      problems.push(`${JSON.stringify(entry)} is not a string.`);
+      continue;
+    }
+    if (!entry.startsWith(".")) {
+      problems.push(`"${entry}" must be a file extension starting with a dot.${describeEntry(entry)}`);
+      continue;
+    }
+    if (entry !== entry.toLowerCase()) {
+      problems.push(`"${entry}" must be lower-case.${describeEntry(entry)}`);
+      continue;
+    }
+    if (!EXTENSION_PATTERN.test(entry)) {
+      problems.push(`"${entry}" is not a valid file extension.`);
+      continue;
+    }
+    if (!out.includes(entry))
+      out.push(entry);
+  }
+  if (problems.length > 0) {
+    throw new Error(`artifact({ accept }): ${problems.join(" ")}`);
+  }
+  return out;
+}
+function artifact(options = {}) {
+  const keyword = {
+    accept: normalizeArtifactAccept(options.accept)
+  };
+  return exports_external.string().brand().meta({ [ARTIFACT_SCHEMA_KEYWORD]: keyword });
+}
+var toMarkerRef = (target) => typeof target === "string" ? { type: "path", pattern: target } : {
+  type: "signal",
+  stepKey: target.step.key,
+  signalKey: target.path
+};
+var Artifact = {
+  path(relativePath) {
+    return relativePath;
+  },
+  embed(target, options) {
+    return buildArtifactMarker("embed", toMarkerRef(target), options.caption);
+  },
+  link(target, options) {
+    return buildArtifactMarker("link", toMarkerRef(target), options.label);
+  }
+};
+// src/definitions/steps/prompt-template.ts
+function createPromptInputProxy(path = []) {
+  const token = () => path.length ? `{{${path.join(".")}}}` : "";
+  return new Proxy(Object.freeze({}), {
+    get(_, key) {
+      if (key === Symbol.toPrimitive || key === "valueOf") {
+        return (_hint) => token();
+      }
+      if (key === "toString") {
+        return () => token();
+      }
+      if (typeof key !== "string")
+        return;
+      return createPromptInputProxy([...path, key]);
+    }
+  });
+}
+function createPromptTemplateContext() {
+  return {
+    input: createPromptInputProxy(["input"]),
+    env: createPromptInputProxy(["env"]),
+    scarn: {
+      artifactsDir: createPromptInputProxy([
+        "scarn",
+        "artifactsDir"
+      ])
+    }
+  };
+}
+function renderPromptTemplate(template, contextJson) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_, path) => {
+    const value = path.split(".").reduce((curr, key) => curr != null ? curr[key] : undefined, contextJson);
+    return value != null ? String(value) : "";
+  });
+}
+
+// src/definitions/steps/env.ts
+var SECRET_LOOKING_NAME = /SECRET|TOKEN|PASSWORD|PASSWD|API_?KEY|PRIVATE/i;
+function isSecretLookingEnvName(name) {
+  return SECRET_LOOKING_NAME.test(name);
+}
+var helperEntries = new WeakSet;
+function brand(entry) {
+  helperEntries.add(entry);
+  return entry;
+}
+var Env = {
+  value(opts) {
+    return brand({
+      kind: "value",
+      value: opts.value,
+      secret: opts.secret ?? false,
+      unsafeAllowStatic: opts.unsafeAllowStatic ?? false,
+      applies: opts.applies ?? "agent"
+    });
+  },
+  inherit(opts) {
+    return brand({
+      kind: "inherit",
+      from: opts?.from,
+      secret: opts?.secret ?? false,
+      optional: opts?.optional ?? false,
+      default: opts?.default,
+      applies: opts?.applies ?? "agent"
+    });
+  }
+};
+function isHelperEntry(entry) {
+  return typeof entry === "object" && helperEntries.has(entry);
+}
+function assertNotStaticSecret(name, value, flags) {
+  if (containsInputToken(value))
+    return;
+  if (flags.secret) {
+    throw new Error(`Env "${name}": a secret must interpolate an input token; a static secret would be stored in plaintext. Use Env.inherit({ secret: true }) to read it from the worker.`);
+  }
+  if (isSecretLookingEnvName(name) && !flags.unsafeAllowStatic) {
+    throw new Error(`Env "${name}": a static value on a secret-looking name would be stored in plaintext. Use Env.inherit({ secret: true }) to read it from the worker, or Env.value({ value, unsafeAllowStatic: true }) if it is not actually secret.`);
+  }
+}
+function appliesField(applies) {
+  return applies === "agent" ? {} : { applies };
+}
+function toEnvVarSpec(name, entry) {
+  if (!isHelperEntry(entry)) {
+    const value = `${entry}`;
+    assertNotStaticSecret(name, value, {
+      secret: false,
+      unsafeAllowStatic: false
+    });
+    return { name, source: "value", value, secret: false };
+  }
+  if (entry.kind === "value") {
+    assertNotStaticSecret(name, entry.value, entry);
+    return {
+      name,
+      source: "value",
+      value: entry.value,
+      secret: entry.secret,
+      ...appliesField(entry.applies)
+    };
+  }
+  return {
+    name,
+    source: "inherit",
+    from: entry.from ?? name,
+    secret: entry.secret,
+    optional: entry.optional,
+    ...entry.default !== undefined ? { default: entry.default } : {},
+    ...appliesField(entry.applies)
+  };
+}
+function normalizeEnv(fn) {
+  if (!fn)
+    return null;
+  const record2 = fn({ input: createPromptInputProxy(["input"]) });
+  const specs = Object.entries(record2).map(([name, entry]) => toEnvVarSpec(name, entry));
+  return specs.length > 0 ? specs : null;
+}
+
+// src/definitions/steps/repo.ts
+var Repo = {
+  none() {
+    return { mode: "none" };
+  },
+  readOnly() {
+    return { mode: "readOnly" };
+  },
+  readWrite(opts) {
+    return { mode: "readWrite", ...opts };
+  }
+};
+function executionModeOf(runtime) {
+  return runtime?.kind === "host" ? "no_workspace" : "workspace";
+}
+function compileRepo(repo, runtime, ctx = {}) {
+  if (repo === undefined)
+    return;
+  const spec = typeof repo === "function" ? repo({
+    input: createPromptInputProxy(["input"]),
+    result: createPromptInputProxy(["result"])
+  }) : repo;
+  const where = ctx.stepKey ? `Step "${ctx.stepKey}" repo` : "repo";
+  const executionMode = executionModeOf(runtime);
+  const mismatch = repoRuntimeMismatch(executionMode, spec.mode);
+  if (mismatch !== null) {
+    throw new Error(`${where} "${spec.mode}" cannot be used with executionMode "${executionMode}": ${mismatch}.`);
+  }
+  const config2 = spec.mode === "readWrite" ? toReadWriteConfig(spec) : { mode: spec.mode };
+  const parsed = repoConfigInputSchema.safeParse(config2);
+  if (!parsed.success) {
+    throw new Error(`${where}: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "mode"} ${issue.message}`).join("; ")}`);
+  }
+  return config2;
+}
+function toReadWriteConfig(spec) {
+  return {
+    mode: "readWrite",
+    ...spec.message !== undefined ? {
+      message: `${spec.message}`
+    } : {},
+    ...spec.onPushFailure !== undefined ? { onPushFailure: spec.onPushFailure } : {}
+  };
+}
+
+// src/definitions/steps/runtime.ts
+var managedRuntimeFactories = Object.fromEntries(MANAGED_RUNTIME_IDS.map((id) => [id, () => ({ kind: "managed", id })]));
+var Runtime = {
+  managed: managedRuntimeFactories,
+  devcontainer(opts) {
+    if (opts?.config === undefined)
+      return { kind: "devcontainer" };
+    const parsed = devcontainerConfigPathSchema.safeParse(opts.config);
+    if (!parsed.success) {
+      throw new Error(`Runtime.devcontainer config "${opts.config}": ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+    }
+    return { kind: "devcontainer", config: parsed.data };
+  },
+  host() {
+    return { kind: "host" };
+  }
+};
+function assertNoSetupVarsOnHost(envJson, runtime, stepKey) {
+  if (runtime?.kind !== "host")
+    return;
+  const setupVar = (envJson ?? []).find((entry) => (entry.applies ?? "agent") !== "agent");
+  if (!setupVar)
+    return;
+  throw new Error(`${stepKey ? `Step "${stepKey}" ` : ""}env "${setupVar.name}": applies "${String(setupVar.applies)}" needs a container to set up, but Runtime.host() has none. Use applies "agent" or Runtime.devcontainer().`);
+}
+function compileEnvironment(environment, ctx = {}) {
+  const runtime = environment?.runtime ?? ctx.defaultRuntime;
+  const envJson = normalizeEnv(environment?.vars);
+  assertNoSetupVarsOnHost(envJson, runtime, ctx.stepKey);
+  return {
+    executionMode: runtime?.kind === "host" ? "no_workspace" : "workspace",
+    devcontainerConfigPath: runtime?.kind === "devcontainer" ? runtime.config ?? null : null,
+    managedRuntime: runtime?.kind === "managed" ? runtime.id : null,
+    envJson,
+    repo: compileRepo(environment?.repo, runtime, ctx)
+  };
+}
+
+// src/definitions/steps/mcp-server-config.ts
+var ownedFields = { type: true, disabled: true };
+var refFieldsSchema = openCodeMcpRefConfigSchema.omit({
+  ...ownedFields,
+  name: true
+});
+var localFieldsSchema = openCodeMcpLocalConfigSchema.omit(ownedFields);
+var remoteFieldsSchema = openCodeMcpRemoteConfigSchema.omit(ownedFields);
+var commonConfigKeys = new Set([
+  "type",
+  "name",
+  "env",
+  "optionalEnv",
+  "healthChecks"
+]);
+function formatIssues(error) {
+  return error.issues.map((issue) => issue.path.length > 0 ? `${issue.path.map(String).join(".")}: ${issue.message}` : issue.message).join("; ");
+}
+function parseFields(name, schema, config2) {
+  const fields = Object.fromEntries(Object.entries(config2).filter(([key]) => !commonConfigKeys.has(key)));
+  const parsed = schema.safeParse(fields);
+  if (!parsed.success) {
+    throw new Error(`defineMcp "${name}": ${formatIssues(parsed.error)}`);
+  }
+  return parsed.data;
+}
+function assertPlaceholders(name, field, values) {
+  for (const [key, value] of Object.entries(values ?? {})) {
+    if (isEnvPlaceholderValue(value))
+      continue;
+    throw new Error(`defineMcp "${name}": ${field}.${key} must be written as {env:VAR}; a literal ${field} value would be stored in plaintext.`);
+  }
+}
+function inferredMcpEnv(definition) {
+  return definition.type === "ref" ? [] : collectEnvPlaceholderNames(definition.server);
+}
+function assertInferredEnv(definition) {
+  for (const variable of inferredMcpEnv(definition)) {
+    if (!ENV_VAR_NAME_PATTERN.test(variable)) {
+      throw new Error(`defineMcp "${definition.name}": {env:${variable}} must name a variable matching ${String(ENV_VAR_NAME_PATTERN)}.`);
+    }
+    if (isReservedEnvVarName(variable)) {
+      throw new Error(`defineMcp "${definition.name}": {env:${variable}} reads a variable reserved for Scarn.`);
+    }
+  }
+}
+function parseMcpServer(config2) {
+  if (typeof config2.name !== "string" || config2.name.trim().length === 0) {
+    throw new Error("defineMcp: name must be a non-empty string.");
+  }
+  const { name } = config2;
+  let definition;
+  switch (config2.type) {
+    case "ref":
+      definition = {
+        type: "ref",
+        name,
+        server: parseFields(name, refFieldsSchema, config2)
+      };
+      break;
+    case "local": {
+      const server = parseFields(name, localFieldsSchema, config2);
+      assertPlaceholders(name, "environment", server.environment);
+      definition = { type: "local", name, server };
+      break;
+    }
+    case "remote": {
+      const server = parseFields(name, remoteFieldsSchema, config2);
+      assertPlaceholders(name, "headers", server.headers);
+      definition = { type: "remote", name, server };
+      break;
+    }
+    default:
+      throw new Error(`defineMcp "${name}": type must be "ref", "local" or "remote".`);
+  }
+  assertInferredEnv(definition);
+  return definition;
+}
+
+// src/definitions/steps/define-mcp.ts
+var mcpCheckInputSchema = toolHealthCheckSchema.omit({ kind: true, mcp: true, name: true }).extend({ enabled: exports_external.boolean().optional() }).strict();
+var mcpCheckPatchSchema = toolHealthCheckSchema.pick({
+  tool: true,
+  args: true,
+  timeoutSeconds: true,
+  severity: true,
+  serialGroup: true
+}).partial().strict();
+var handles = new WeakSet;
+function isMcpHandle(value) {
+  return typeof value === "object" && value !== null && handles.has(value);
+}
+function deepFreeze(value) {
+  if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value))
+      deepFreeze(child);
+  }
+  return value;
+}
+function frozenCopy(value) {
+  return deepFreeze(structuredClone(value));
+}
+function formatIssues2(error) {
+  return error.issues.map((issue) => issue.path.length > 0 ? `${issue.path.map(String).join(".")}: ${issue.message}` : issue.message).join("; ");
+}
+function assertCheckName(label, name) {
+  if (name.trim().length === 0 || name.includes(".")) {
+    throw new Error(`defineMcp "${label}": health check name "${name}" must be non-empty and contain no ".".`);
+  }
+}
+function assertCheckInput(label, name, check2) {
+  assertCheckName(label, name);
+  const parsed = mcpCheckInputSchema.safeParse(check2);
+  if (!parsed.success) {
+    throw new Error(`defineMcp "${label}" health check "${name}": ${formatIssues2(parsed.error)}`);
+  }
+}
+function assertEnvNames(label, env, optionalEnv) {
+  const seen = new Set;
+  for (const name of [...env, ...optionalEnv]) {
+    if (!ENV_VAR_NAME_PATTERN.test(name)) {
+      throw new Error(`defineMcp "${label}": env var "${name}" must match ${String(ENV_VAR_NAME_PATTERN)}.`);
+    }
+    if (isReservedEnvVarName(name)) {
+      throw new Error(`defineMcp "${label}": env var "${name}" is reserved for Scarn.`);
+    }
+    if (seen.has(name)) {
+      throw new Error(`defineMcp "${label}": env var "${name}" is declared more than once.`);
+    }
+    seen.add(name);
+  }
+}
+function knownCheckNames(state) {
+  const names = new Set(Object.keys(state.checks));
+  for (const op of state.overrides) {
+    if (op.op === "add")
+      names.add(op.name);
+  }
+  return names;
+}
+function assertKnownCheck(state, method, name) {
+  const known = knownCheckNames(state);
+  if (known.has(name))
+    return;
+  throw new Error(`defineMcp "${state.name}".${method}: unknown health check "${name}". Known checks: ${known.size > 0 ? [...known].join(", ") : "(none)"}.`);
+}
+function withOp(state, op) {
+  return createHandle({
+    ...state,
+    overrides: Object.freeze([...state.overrides, deepFreeze(op)])
+  });
+}
+function createHandle(state) {
+  const handle = {
+    ...state,
+    overrideCheck: (name, patch) => {
+      assertKnownCheck(state, "overrideCheck", name);
+      const parsed = mcpCheckPatchSchema.safeParse(patch);
+      if (!parsed.success) {
+        throw new Error(`defineMcp "${state.name}".overrideCheck("${name}"): ${formatIssues2(parsed.error)}`);
+      }
+      return withOp(state, {
+        op: "override",
+        name,
+        patch: structuredClone(patch)
+      });
+    },
+    disableCheck: (name) => {
+      assertKnownCheck(state, "disableCheck", name);
+      return withOp(state, { op: "disable", name });
+    },
+    enableCheck: (name) => {
+      assertKnownCheck(state, "enableCheck", name);
+      return withOp(state, { op: "enable", name });
+    },
+    addCheck: (name, check2) => {
+      assertCheckInput(state.name, name, check2);
+      if (knownCheckNames(state).has(name)) {
+        throw new Error(`defineMcp "${state.name}".addCheck: health check "${name}" already exists; use overrideCheck to change it.`);
+      }
+      return withOp(state, { op: "add", name, check: structuredClone(check2) });
+    },
+    disableAllChecks: () => withOp(state, { op: "disableAll" })
+  };
+  handles.add(handle);
+  return Object.freeze(handle);
+}
+function defineMcp(config2) {
+  const definition = parseMcpServer(config2);
+  const env = config2.env ?? [];
+  const optionalEnv = config2.optionalEnv ?? [];
+  assertEnvNames(definition.name, env, optionalEnv);
+  const checks = config2.healthChecks ?? {};
+  for (const [name, check2] of Object.entries(checks)) {
+    assertCheckInput(definition.name, name, check2);
+  }
+  return createHandle({
+    ...frozenCopy(definition),
+    env: frozenCopy([...env]),
+    optionalEnv: frozenCopy([...optionalEnv]),
+    checks: frozenCopy({ ...checks }),
+    overrides: Object.freeze([])
+  });
+}
+function resolveMcpChecks(handle) {
+  const resolved = new Map;
+  for (const [name, check2] of Object.entries(handle.checks)) {
+    resolved.set(name, { check: { ...check2 }, enabled: check2.enabled ?? true });
+  }
+  for (const op of handle.overrides) {
+    if (op.op === "add") {
+      resolved.set(op.name, {
+        check: { ...op.check },
+        enabled: op.check.enabled ?? true
+      });
+    } else if (op.op === "disableAll") {
+      for (const entry of resolved.values())
+        entry.enabled = false;
+    } else {
+      const entry = resolved.get(op.name);
+      if (!entry)
+        continue;
+      if (op.op === "override")
+        entry.check = { ...entry.check, ...op.patch };
+      else
+        entry.enabled = op.op === "enable";
+    }
+  }
+  return [...resolved].map(([name, { check: check2, enabled }]) => ({
+    name,
+    check: check2,
+    enabled
+  }));
+}
+
+// src/definitions/steps/compile-mcps.ts
+function compileServer(key, handle) {
+  switch (handle.type) {
+    case "ref":
+      return {
+        type: "ref",
+        ...handle.name !== key ? { name: handle.name } : {},
+        ...structuredClone(handle.server)
+      };
+    case "local":
+      return { type: "local", ...structuredClone(handle.server) };
+    case "remote":
+      return { type: "remote", ...structuredClone(handle.server) };
+  }
+}
+function compileChecks(key, handle) {
+  return resolveMcpChecks(handle).filter((resolved) => resolved.enabled).map(({ name, check: check2 }) => ({
+    kind: "tool",
+    mcp: key,
+    name: `${key}.${name}`,
+    tool: check2.tool,
+    ...check2.args !== undefined ? { args: check2.args } : {},
+    ...check2.timeoutSeconds !== undefined ? { timeoutSeconds: check2.timeoutSeconds } : {},
+    serialGroup: check2.serialGroup ?? key,
+    severity: check2.severity ?? "required"
+  }));
+}
+function compileEnv(key, handle) {
+  const entry = (name, optional2) => ({
+    source: "inherit",
+    name,
+    from: name,
+    secret: true,
+    optional: optional2,
+    mcp: key,
+    applies: "agent"
+  });
+  const listed = new Set([...handle.env, ...handle.optionalEnv]);
+  const inferred = inferredMcpEnv(handle).filter((name) => !listed.has(name));
+  return [
+    ...handle.env.map((name) => entry(name, false)),
+    ...inferred.map((name) => entry(name, false)),
+    ...handle.optionalEnv.map((name) => entry(name, true))
+  ];
+}
+function dedupeEnv(entries) {
+  const byName = new Map;
+  for (const entry of entries) {
+    const existing = byName.get(entry.name);
+    if (!existing) {
+      byName.set(entry.name, entry);
+      continue;
+    }
+    byName.set(entry.name, {
+      source: "inherit",
+      name: entry.name,
+      from: entry.from,
+      secret: true,
+      optional: existing.optional && entry.optional,
+      applies: "agent"
+    });
+  }
+  return [...byName.values()];
+}
+function compileMcps(mcps, stepKey) {
+  const compiled = {
+    opencodeMcpJson: {},
+    healthChecks: [],
+    envEntries: []
+  };
+  for (const [key, handle] of Object.entries(mcps)) {
+    if (!isMcpHandle(handle)) {
+      throw new Error(`Step "${stepKey}" mcps.${key}: expected a handle from defineMcp().`);
+    }
+    compiled.opencodeMcpJson[key] = compileServer(key, handle);
+    compiled.healthChecks.push(...compileChecks(key, handle));
+    compiled.envEntries.push(...compileEnv(key, handle));
+  }
+  compiled.envEntries = dedupeEnv(compiled.envEntries);
+  return compiled;
+}
+function nonEmpty(items) {
+  return items.length > 0 ? items : null;
+}
+function mergeStepMcps(stepKey, input) {
+  if (!input.mcps || Object.keys(input.mcps).length === 0) {
+    return {
+      opencodeMcpJson: null,
+      healthChecksJson: input.healthChecks ?? null,
+      envJson: input.envJson
+    };
+  }
+  const compiled = compileMcps(input.mcps, stepKey);
+  const stepVars = input.envJson ?? [];
+  const stepVarNames = new Set(stepVars.map((entry) => entry.name));
+  return {
+    opencodeMcpJson: compiled.opencodeMcpJson,
+    healthChecksJson: nonEmpty([
+      ...compiled.healthChecks,
+      ...input.healthChecks ?? []
+    ]),
+    envJson: nonEmpty([
+      ...compiled.envEntries.filter((entry) => !stepVarNames.has(entry.name)),
+      ...stepVars
+    ])
+  };
+}
+
+// src/definitions/steps/step-handle.ts
+function compileStepErrors(stepKey, errors) {
+  const names = [...errors ?? []];
+  const seen = new Set;
+  for (const name of names) {
+    if (name.trim() === "") {
+      throw new Error(`Step "${stepKey}": error names must not be empty.`);
+    }
+    if (seen.has(name)) {
+      throw new Error(`Step "${stepKey}": error "${name}" is declared more than once.`);
+    }
+    seen.add(name);
+  }
+  return names;
+}
+function compileStepRetry(stepKey, retry, errors) {
+  const known = new Set([...BUILT_IN_ERRORS, ...errors]);
+  return (retry ?? []).map((entry) => {
+    if (entry.on.length === 0) {
+      throw new Error(`Step "${stepKey}": each retry must name an error.`);
+    }
+    const unknown2 = entry.on.find((name) => !known.has(name));
+    if (unknown2 !== undefined) {
+      throw new Error(`Step "${stepKey}": retry names "${unknown2}", which is neither a built-in error nor one the step declares.`);
+    }
+    if (!Number.isInteger(entry.maxAttempts) || entry.maxAttempts <= 0) {
+      throw new Error(`Step "${stepKey}": retry maxAttempts must be a positive integer.`);
+    }
+    return { on: [...entry.on], maxAttempts: entry.maxAttempts };
+  });
+}
+function toStepHandle(spec) {
+  const node = stepNode(spec);
+  const call = stepCall(node);
+  const { name, ...rest } = spec;
+  Object.defineProperty(call, "name", {
+    value: name,
+    enumerable: true
+  });
+  Object.assign(call, rest);
+  return makeHandle(call, node);
+}
+function toStepSpec(step) {
+  return { ...step };
+}
+
+// src/definitions/steps/define-step.ts
+function assertStepMcpInput(config2) {
+  if ("mcpServers" in config2) {
+    throw new Error(`Step "${config2.key}": mcpServers is not supported. Declare each MCP server with defineMcp({ type: "ref" | "local" | "remote", ... }) and list it under mcps.`);
+  }
+  if (config2.healthChecks == null)
+    return;
+  const parsed = stepHealthChecksInputSchema.safeParse(config2.healthChecks);
+  if (parsed.success)
+    return;
+  const issues = parsed.error.issues.map((issue) => issue.path.length > 0 ? `${issue.path.map(String).join(".")}: ${issue.message}` : issue.message).join("; ");
+  throw new Error(`Step "${config2.key}" healthChecks: ${issues}. MCP health checks are declared on the server with defineMcp({ healthChecks }).`);
+}
+function defineStep(config2) {
+  const features = config2.features ?? [];
+  let effectiveResult = config2.result;
+  for (const feature of features) {
+    effectiveResult = effectiveResult ? effectiveResult.extend(feature._resultExtension.shape) : feature._resultExtension;
+  }
+  const basePrompt = typeof config2.agentPrompt === "function" ? config2.agentPrompt(createPromptTemplateContext()) : config2.agentPrompt;
+  let effectivePrompt = basePrompt;
+  for (const feature of features) {
+    if (feature._promptAddition) {
+      effectivePrompt = effectivePrompt ? `${effectivePrompt}
+
+${feature._promptAddition}` : feature._promptAddition;
+    }
+  }
+  const {
+    executionMode,
+    devcontainerConfigPath,
+    managedRuntime,
+    envJson,
+    repo
+  } = compileEnvironment(config2.environment, { stepKey: config2.key });
+  assertStepMcpInput(config2);
+  const mcpFields = mergeStepMcps(config2.key, {
+    mcps: config2.mcps,
+    healthChecks: config2.healthChecks,
+    envJson
+  });
+  const resultSchemaJson = effectiveResult ? toJSONSchema(effectiveResult) : null;
+  const spec = {
+    key: config2.key,
+    name: config2.name,
+    description: config2.description ?? null,
+    version: config2.version ?? 1,
+    kind: "user_defined",
+    status: config2.status ?? "active",
+    executionMode,
+    devcontainerConfigPath,
+    ...managedRuntime !== null ? { managedRuntime } : {},
+    prompt: effectivePrompt,
+    inputSchemaJson: config2.additionalInput ? toJSONSchema(config2.additionalInput) : null,
+    resultSchemaJson,
+    opencodeMcpJson: mcpFields.opencodeMcpJson,
+    healthChecksJson: mcpFields.healthChecksJson,
+    envJson: mcpFields.envJson,
+    ...repo !== undefined ? { repo } : {},
+    errors: compileStepErrors(config2.key, config2.errors),
+    retryJson: compileStepRetry(config2.key, config2.retry, config2.errors ?? [])
+  };
+  return toStepHandle(spec);
+}
+// src/definitions/steps/define-code-step.ts
+function codeStep(config2) {
+  const features = config2.features ?? [];
+  let effectiveResult = config2.resultSchema;
+  for (const feature of features) {
+    effectiveResult = effectiveResult ? effectiveResult.extend(feature._resultExtension.shape) : feature._resultExtension;
+  }
+  const {
+    executionMode,
+    devcontainerConfigPath,
+    managedRuntime,
+    envJson,
+    repo
+  } = compileEnvironment(config2.environment, {
+    stepKey: config2.key,
+    defaultRuntime: Runtime.managed[DEFAULT_CODE_STEP_RUNTIME_ID]()
+  });
+  const spec = {
+    key: config2.key,
+    name: config2.name,
+    description: config2.description ?? null,
+    version: config2.version ?? 1,
+    kind: "code",
+    status: config2.status ?? "active",
+    executionMode,
+    devcontainerConfigPath,
+    managedRuntime,
+    prompt: null,
+    inputSchemaJson: config2.inputSchema ? toJSONSchema(config2.inputSchema) : null,
+    resultSchemaJson: effectiveResult ? toJSONSchema(effectiveResult) : null,
+    opencodeMcpJson: null,
+    healthChecksJson: null,
+    envJson,
+    ...repo !== undefined ? { repo } : {},
+    errors: compileStepErrors(config2.key, config2.errors),
+    retryJson: compileStepRetry(config2.key, config2.retry, config2.errors ?? []),
+    entrypoint: { fn: config2.fn }
+  };
+  return toStepHandle(spec);
+}
+// src/definitions/steps/step-definitions-client.ts
+var ANY_OBJECT_SCHEMA = { type: "object" };
+function createStepDefinitionsClient(baseUrl) {
+  const client = createClient({ baseUrl });
+  return buildStepDefinitionsClient(new StepDefinitions({ client }));
+}
+var buildStepDefinitionsClient = (stepDefinitions) => {
+  return {
+    listByProjectId: async (projectId, options) => {
+      const result = await stepDefinitions.listStepDefinitions({
+        query: { projectId },
+        headers: options?.headers
+      });
+      if (result.error)
+        throw new Error(JSON.stringify(result.error));
+      return result.data;
+    },
+    create: async (body, options) => {
+      const result = await stepDefinitions.createStepDefinition({
+        body,
+        headers: options?.headers
+      });
+      if (result.error)
+        throw new Error(JSON.stringify(result.error));
+      return result.data;
+    },
+    upsertFromSpec: async (projectId, step, options) => {
+      const spec = toStepSpec(step);
+      const body = {
+        key: spec.key,
+        name: spec.name,
+        description: spec.description,
+        prompt: spec.prompt ?? null,
+        version: spec.version,
+        kind: spec.kind,
+        entrypointJson: spec.entrypointJson ?? null,
+        executionMode: spec.executionMode,
+        devcontainerConfigPath: spec.devcontainerConfigPath,
+        managedRuntime: spec.managedRuntime,
+        repo: spec.repo,
+        inputSchemaJson: spec.inputSchemaJson ?? ANY_OBJECT_SCHEMA,
+        resultSchemaJson: spec.kind === "code" ? spec.resultSchemaJson ?? ANY_OBJECT_SCHEMA : spec.resultSchemaJson,
+        opencodeMcpJson: spec.opencodeMcpJson,
+        healthChecksJson: spec.healthChecksJson,
+        envJson: spec.envJson,
+        errors: [...spec.errors ?? []],
+        retry: (spec.retryJson ?? []).map((entry) => ({
+          on: [...entry.on],
+          maxAttempts: entry.maxAttempts
+        })),
+        status: spec.status,
+        projectId
+      };
+      const result = await stepDefinitions.upsertStepDefinition({
+        body,
+        headers: options?.headers
+      });
+      if (result.error)
+        throw new Error(JSON.stringify(result.error));
+      return result.data;
+    }
+  };
+};
+// src/definitions/steps/step-features.ts
+var notificationKindSchema = exports_external.enum([
+  "feedback_request",
+  "status_update",
+  "blocked",
+  "result_ready",
+  "warning"
+]);
+var notificationPrioritySchema = exports_external.enum(["low", "normal", "high", "urgent"]);
+var notificationChannelSchema = exports_external.enum([
+  "in_app",
+  "work_item_platform_comment",
+  "email",
+  "slack"
+]);
+var NOTIFICATION_RESULT_KEY = "$scarn_notifications_v1";
+var DEFAULT_NOTIFICATION_KIND = "status_update";
+var notificationItemSchema = exports_external.object({
+  kind: notificationKindSchema.describe("The kind of user notification."),
+  title: exports_external.string().optional().describe("Short, human-readable notification title."),
+  body: exports_external.string().describe("The notification body / details."),
+  priority: notificationPrioritySchema.describe("How important this notification is for the user."),
+  suggestedChannels: exports_external.array(notificationChannelSchema).optional().describe("Channels the agent thinks are worth using. The platform policy decides the final channels."),
+  payload: exports_external.record(exports_external.string(), exports_external.unknown()).optional().describe('Kind-specific structured data. For "feedback_request": { category, urgency }.')
+}).describe("A single user notification emitted by the agent.");
+var notificationsFeature = {
+  _resultExtension: exports_external.object({
+    [NOTIFICATION_RESULT_KEY]: exports_external.array(notificationItemSchema).optional()
+  }),
+  _promptAddition: [
+    "## User Notifications",
+    "",
+    `If you need to communicate something to a human, populate the \`${NOTIFICATION_RESULT_KEY}\` array.`,
+    "Each item must include:",
+    "- **kind**: One of `feedback_request`, `status_update`, `blocked`, `result_ready`, `warning`.",
+    "- **title**: A short, human-readable title.",
+    "- **body**: The details of the notification.",
+    "- **priority**: One of `low`, `normal`, `high`, `urgent`.",
+    '- **suggestedChannels** *(optional)*: Channels you think are worth using (e.g. `["in_app", "work_item_platform_comment"]`).',
+    "  You only *suggest* channels \u2014 the platform policy decides the final delivery channels.",
+    "  Suggesting `work_item_platform_comment` does NOT post anything directly: it always requires a human to review the exact text and explicitly approve it before it's posted to the work item's originating platform issue (e.g. GitHub) \u2014 it becomes a pending draft on that comment thread, not an immediate post.",
+    '- **payload** *(optional)*: Kind-specific data. For `feedback_request`, include `{ "category": string, "urgency": "blocking"|"clarification"|"assumption"|"informational" }`.',
+    "",
+    "### Artifacts in comments",
+    "",
+    "A `work_item_platform_comment` body can show or link files this pipeline run produced, using artifact markers:",
+    "- `![caption](artifact:signal/<stepKey>/<resultPath>)` embeds the artifact field at `<resultPath>` in that step's result where the platform can show it, and links to it otherwise. `[label](artifact:signal/<stepKey>/<resultPath>)` links to it. If that artifact is unavailable, the comment is not drafted.",
+    "- `![caption](artifact:<name-or-glob>)` and `[label](artifact:<name-or-glob>)` do the same for any file under the artifacts folder, e.g. `artifact:screenshots/*.png`. If nothing matches, the marker's paragraph is left out.",
+    "Rules:",
+    "- One marker per paragraph: put each marker on its own line, with a blank line before and after. A marker inside a sentence is only linked.",
+    `- Don't refer to an artifact outside its marker (no "see the video below"). Put any description in the caption or label, so the comment still reads correctly if the marker is left out.`
+  ].join(`
+`)
+};
+var feedbackRequestsFeature = {
+  _resultExtension: exports_external.object({
+    [NOTIFICATION_RESULT_KEY]: exports_external.array(notificationItemSchema.extend({ kind: exports_external.literal("feedback_request") })).optional()
+  }),
+  _promptAddition: [
+    "## Feedback Requests",
+    "",
+    `If you need to ask a human a clarifying question, populate the \`${NOTIFICATION_RESULT_KEY}\` array with items of kind \`"feedback_request"\`.`,
+    "Each item must include:",
+    "- **title**: A short, human-readable summary of the question.",
+    "- **body**: The full question.",
+    "- **priority**: One of `low`, `normal`, `high`, `urgent`.",
+    '- **payload**: `{ "category": string, "urgency": "blocking"|"clarification"|"assumption"|"informational" }`.'
+  ].join(`
+`)
+};
+var Features = {
+  notifications: () => notificationsFeature,
+  feedbackRequests: () => feedbackRequestsFeature
+};
+var Notify = {
+  create: (item) => ({
+    [NOTIFICATION_RESULT_KEY]: [item]
+  }),
+  inApp: (title, body, priority, options) => Notify.create({
+    kind: options?.kind ?? DEFAULT_NOTIFICATION_KIND,
+    title,
+    body,
+    priority,
+    suggestedChannels: ["in_app"],
+    ...options?.payload ? { payload: options.payload } : {}
+  }),
+  feedbackRequest: (question, category, urgency) => Notify.create({
+    kind: "feedback_request",
+    title: question,
+    body: question,
+    priority: "normal",
+    payload: { category, urgency }
+  }),
+  merge: (...fragments) => ({
+    [NOTIFICATION_RESULT_KEY]: fragments.flatMap((fragment) => fragment[NOTIFICATION_RESULT_KEY])
+  })
+};
+export { ARTIFACT_BRAND, ArtifactTypes, normalizeArtifactAccept, artifact, Artifact, exports_z, createPromptInputProxy, createPromptTemplateContext, renderPromptTemplate, isSecretLookingEnvName, Env, normalizeEnv, Repo, compileRepo, Runtime, compileEnvironment, isMcpHandle, defineMcp, resolveMcpChecks, compileMcps, compileStepErrors, compileStepRetry, toStepHandle, toStepSpec, defineStep, codeStep, createStepDefinitionsClient, Features, Notify };