@autohq/cli 0.1.683 → 0.1.684

package/dist/agent-bridge.js

@@ -3729,7 +3729,7 @@ var require_identity = __commonJS({
     var NODE_TYPE = /* @__PURE__ */ Symbol.for("yaml.node.type");
     var isAlias = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === ALIAS;
     var isDocument = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === DOC;
-    var isMap = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === MAP;
+    var isMap2 = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === MAP;
     var isPair = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === PAIR;
     var isScalar = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SCALAR;
     var isSeq = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SEQ;
@@ -3765,7 +3765,7 @@ var require_identity = __commonJS({
     exports.isAlias = isAlias;
     exports.isCollection = isCollection;
     exports.isDocument = isDocument;
-    exports.isMap = isMap;
+    exports.isMap = isMap2;
     exports.isNode = isNode;
     exports.isPair = isPair;
     exports.isScalar = isScalar;
@@ -7875,9 +7875,9 @@ var require_resolve_flow_collection = __commonJS({
     var blockMsg = "Block collections are not allowed within flow collections";
     var isBlock = (token) => token && (token.type === "block-map" || token.type === "block-seq");
     function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc2, onError, tag) {
-      const isMap = fc2.start.source === "{";
-      const fcName = isMap ? "flow map" : "flow sequence";
-      const NodeClass = tag?.nodeClass ?? (isMap ? YAMLMap.YAMLMap : YAMLSeq.YAMLSeq);
+      const isMap2 = fc2.start.source === "{";
+      const fcName = isMap2 ? "flow map" : "flow sequence";
+      const NodeClass = tag?.nodeClass ?? (isMap2 ? YAMLMap.YAMLMap : YAMLSeq.YAMLSeq);
       const coll = new NodeClass(ctx.schema);
       coll.flow = true;
       const atRoot = ctx.atRoot;
@@ -7913,7 +7913,7 @@ var require_resolve_flow_collection = __commonJS({
             offset = props.end;
             continue;
           }
-          if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key))
+          if (!isMap2 && ctx.options.strict && utilContainsNewline.containsNewline(key))
             onError(
               key,
               // checked by containsNewline()
@@ -7953,7 +7953,7 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep6 && !props.found) {
+        if (!isMap2 && !sep6 && !props.found) {
           const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep6, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
@@ -7976,7 +7976,7 @@ var require_resolve_flow_collection = __commonJS({
             startOnNewline: false
           });
           if (valueProps.found) {
-            if (!isMap && !props.found && ctx.options.strict) {
+            if (!isMap2 && !props.found && ctx.options.strict) {
               if (sep6)
                 for (const st2 of sep6) {
                   if (st2 === valueProps.found)
@@ -8008,7 +8008,7 @@ var require_resolve_flow_collection = __commonJS({
           const pair = new Pair.Pair(keyNode, valueNode);
           if (ctx.options.keepSourceTokens)
             pair.srcToken = collItem;
-          if (isMap) {
+          if (isMap2) {
             const map2 = coll;
             if (utilMapIncludes.mapIncludes(ctx, map2.items, keyNode))
               onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
@@ -8024,7 +8024,7 @@ var require_resolve_flow_collection = __commonJS({
           offset = valueNode ? valueNode.range[2] : valueProps.end;
         }
       }
-      const expectedEnd = isMap ? "}" : "]";
+      const expectedEnd = isMap2 ? "}" : "]";
       const [ce2, ...ee2] = fc2.end;
       let cePos = offset;
       if (ce2?.source === expectedEnd)
@@ -9993,7 +9993,7 @@ var require_lexer = __commonJS({
 var require_line_counter = __commonJS({
   "../../node_modules/yaml/dist/parse/line-counter.js"(exports) {
     "use strict";
-    var LineCounter = class {
+    var LineCounter2 = class {
       constructor() {
         this.lineStarts = [];
         this.addNewLine = (offset) => this.lineStarts.push(offset);
@@ -10016,7 +10016,7 @@ var require_line_counter = __commonJS({
         };
       }
     };
-    exports.LineCounter = LineCounter;
+    exports.LineCounter = LineCounter2;
   }
 });
 
@@ -10910,7 +10910,7 @@ var require_public_api = __commonJS({
       const lineCounter$1 = options.lineCounter || prettyErrors && new lineCounter.LineCounter() || null;
       return { lineCounter: lineCounter$1, prettyErrors };
     }
-    function parseAllDocuments2(source, options = {}) {
+    function parseAllDocuments(source, options = {}) {
       const { lineCounter: lineCounter2, prettyErrors } = parseOptions(options);
       const parser$1 = new parser.Parser(lineCounter2?.addNewLine);
       const composer$1 = new composer.Composer(options);
@@ -10985,7 +10985,7 @@ var require_public_api = __commonJS({
       return new Document.Document(value, _replacer, options).toString(options);
     }
     exports.parse = parse5;
-    exports.parseAllDocuments = parseAllDocuments2;
+    exports.parseAllDocuments = parseAllDocuments;
     exports.parseDocument = parseDocument;
     exports.stringify = stringify;
   }
@@ -33191,11 +33191,11 @@ function decryptRuntimeBridgeBootstrap(input) {
   return { bootstrap, ignoredKeys: ignoredPlaintextKeys(raw) };
 }
 function ignoredPlaintextKeys(raw) {
-  const record2 = external_exports.record(external_exports.string(), external_exports.unknown()).parse(raw);
+  const record3 = external_exports.record(external_exports.string(), external_exports.unknown()).parse(raw);
   const knownKeys = new Set(
     Object.keys(RuntimeBridgeBootstrapPlaintextSchema.shape)
   );
-  return Object.keys(record2).filter((key) => !knownKeys.has(key));
+  return Object.keys(record3).filter((key) => !knownKeys.has(key));
 }
 function deriveBootstrapKey(accessToken, salt) {
   return Buffer.from(
@@ -33218,7 +33218,7 @@ function bootstrapAdditionalData(input) {
 // package.json
 var package_default = {
   name: "@autohq/cli",
-  version: "0.1.683",
+  version: "0.1.684",
   license: "SEE LICENSE IN README.md",
   publishConfig: {
     access: "public"
@@ -34751,6 +34751,20 @@ var SERVICE_ACCOUNT_SCOPE_PRESETS = {
 };
 var ServiceAccountScopePresetSchema = external_exports.enum(["read-only", "applier"]);
 
+// ../../packages/schemas/src/capability-attenuation.ts
+function grantedCapabilityLevel(capability) {
+  return typeof capability === "string" ? capability : capability.level;
+}
+function unattributedCapabilityLevel(capability) {
+  return typeof capability === "string" ? void 0 : capability.unattributed;
+}
+function effectiveCapabilityLevel(capability, requesterEligible) {
+  return requesterEligible ? grantedCapabilityLevel(capability) : unattributedCapabilityLevel(capability) ?? grantedCapabilityLevel(capability);
+}
+function capabilityLevelAtMost(input) {
+  return input.levels.indexOf(input.floor) <= input.levels.indexOf(input.grant);
+}
+
 // ../../packages/schemas/src/conversation.ts
 var CONVERSATION_ROLES = [
   "system",
@@ -35125,25 +35139,25 @@ var ClaudeCodeStreamRecordSchema = external_exports.discriminatedUnion("type", [
   ClaudeCodeResultRecordSchema
 ]);
 function parseClaudeCodeStreamRecord(parsed) {
-  const record2 = ClaudeCodeStreamRecordSchema.parse(parsed);
-  if (record2.type === "system") {
-    const projection = systemProjection(record2);
+  const record3 = ClaudeCodeStreamRecordSchema.parse(parsed);
+  if (record3.type === "system") {
+    const projection = systemProjection(record3);
     return {
       projections: projection ? [projection] : []
     };
   }
-  if (record2.type === "assistant" || record2.type === "user") {
+  if (record3.type === "assistant" || record3.type === "user") {
     return {
-      projections: record2.type === "assistant" ? assistantContentProjections(
-        record2.message,
-        record2.message.id ?? UNKNOWN_MESSAGE_ID
-      ) : userContentProjections(record2.message)
+      projections: record3.type === "assistant" ? assistantContentProjections(
+        record3.message,
+        record3.message.id ?? UNKNOWN_MESSAGE_ID
+      ) : userContentProjections(record3.message)
     };
   }
-  const isError = record2.is_error === true || record2.subtype === "error";
-  const sdkErrorMessage = record2.errors?.map((error51) => error51.trim()).filter(Boolean).join("\n");
-  const errorMessage10 = isError ? record2.error ?? record2.result ?? (sdkErrorMessage || void 0) ?? "claude-code reported an error" : void 0;
-  const usage = claudeCodeUsageFromRecord(record2);
+  const isError = record3.is_error === true || record3.subtype === "error";
+  const sdkErrorMessage = record3.errors?.map((error51) => error51.trim()).filter(Boolean).join("\n");
+  const errorMessage10 = isError ? record3.error ?? record3.result ?? (sdkErrorMessage || void 0) ?? "claude-code reported an error" : void 0;
+  const usage = claudeCodeUsageFromRecord(record3);
   return {
     projections: [],
     result: {
@@ -35153,8 +35167,8 @@ function parseClaudeCodeStreamRecord(parsed) {
     }
   };
 }
-function isClaudeCodeInterruptMarker(record2) {
-  const parsed = ClaudeCodeInterruptMarkerRecordSchema.safeParse(record2);
+function isClaudeCodeInterruptMarker(record3) {
+  const parsed = ClaudeCodeInterruptMarkerRecordSchema.safeParse(record3);
   if (!parsed.success) {
     return false;
   }
@@ -35205,19 +35219,19 @@ function textContent(text) {
     ]
   };
 }
-function systemProjection(record2) {
-  if (record2.subtype === "init") {
+function systemProjection(record3) {
+  if (record3.subtype === "init") {
     return {
       role: "system",
       kind: "status",
       content: textContent(
-        `claude-code session started${record2.model ? ` (${record2.model})` : ""}`
+        `claude-code session started${record3.model ? ` (${record3.model})` : ""}`
       )
     };
   }
-  if (record2.subtype === "api_retry") {
-    const attempt = record2.attempt;
-    const maxRetries = record2.max_retries;
+  if (record3.subtype === "api_retry") {
+    const attempt = record3.attempt;
+    const maxRetries = record3.max_retries;
     return {
       role: "system",
       kind: "status",
@@ -35343,9 +35357,9 @@ function userContentProjections(message) {
   }
   return projections;
 }
-function claudeCodeUsageFromRecord(record2) {
-  const aggregate = record2.usage;
-  const modelUsage = record2.modelUsage;
+function claudeCodeUsageFromRecord(record3) {
+  const aggregate = record3.usage;
+  const modelUsage = record3.modelUsage;
   if (!aggregate && !modelUsage) {
     return void 0;
   }
@@ -35364,7 +35378,7 @@ function claudeCodeUsageFromRecord(record2) {
     outputTokens: tokenCount(aggregate?.output_tokens),
     cacheCreationTokens: tokenCount(aggregate?.cache_creation_input_tokens),
     cacheReadTokens: tokenCount(aggregate?.cache_read_input_tokens),
-    totalCostUsd: usdAmount(record2.total_cost_usd),
+    totalCostUsd: usdAmount(record3.total_cost_usd),
     perModel
   };
 }
@@ -35817,6 +35831,193 @@ function parseApprovalRequest(method, requestId, params) {
   }
 }
 
+// ../../packages/schemas/src/pricing.ts
+var UnknownPricingVersionError = class extends Error {
+  constructor(version2) {
+    super(`Unknown pricing rate-card version: ${version2}`);
+    this.name = "UnknownPricingVersionError";
+  }
+};
+var UnknownPricingModelError = class extends Error {
+  constructor(model, version2) {
+    super(`No pricing for model "${model}" in rate card ${version2}`);
+    this.name = "UnknownPricingModelError";
+  }
+};
+var RATE_CARD_2026_06_23 = {
+  version: "2026-06-23",
+  effectiveAt: "2026-06-23T00:00:00.000Z",
+  models: {
+    "claude-opus-4-8": opusTier(),
+    "claude-opus-4-7": opusTier(),
+    "claude-opus-4-6": opusTier(),
+    "claude-sonnet-4-6": tier(3, 15),
+    "claude-haiku-4-5": tier(1, 5),
+    "claude-haiku-4-5-20251001": tier(1, 5),
+    "claude-fable-5": tier(10, 50),
+    // OpenAI gpt-5.3-codex, standard tier: input $1.75/Mtok, cached input
+    // $0.175/Mtok, output $14.00/Mtok. Source (verified 2026-06-23):
+    // https://developers.openai.com/api/docs/models/gpt-5.3-codex and
+    // https://developers.openai.com/api/docs/pricing (priority tier is 2x; we
+    // bill standard).
+    "gpt-5.3-codex": openAiTier({
+      input: 1.75,
+      cachedInput: 0.175,
+      output: 14
+    })
+  }
+};
+var RATE_CARD_2026_07_04 = {
+  version: "2026-07-04",
+  effectiveAt: "2026-07-04T00:00:00.000Z",
+  models: {
+    ...RATE_CARD_2026_06_23.models,
+    // OpenAI gpt-5.5, standard tier: input $5.00/Mtok, cached input
+    // $0.50/Mtok, output $30.00/Mtok. Source (verified 2026-07-04):
+    // https://developers.openai.com/api/docs/models/gpt-5.5 and
+    // https://developers.openai.com/api/docs/pricing (priority tier is 2x; we
+    // bill standard).
+    "gpt-5.5": openAiTier({
+      input: 5,
+      cachedInput: 0.5,
+      output: 30
+    }),
+    // OpenAI may echo the dated snapshot id on responses even when callers send
+    // the `gpt-5.5` alias. Price that dated id identically so usage enrichment
+    // keeps recording codex-default spend instead of dropping unknown models.
+    "gpt-5.5-2026-04-23": openAiTier({
+      input: 5,
+      cachedInput: 0.5,
+      output: 30
+    })
+  }
+};
+var RATE_CARD_2026_07_07 = {
+  version: "2026-07-07",
+  effectiveAt: "2026-07-07T00:00:00.000Z",
+  models: {
+    ...RATE_CARD_2026_07_04.models,
+    // Anthropic Claude Sonnet 5 list price: input $3/Mtok, output $15/Mtok
+    // (same tier as Sonnet 4.6). Anthropic runs an introductory $2/$10 rate
+    // through 2026-08-31; we bill list, matching the rest of the card.
+    "claude-sonnet-5": tier(3, 15)
+  }
+};
+var RATE_CARD_2026_07_09 = {
+  version: "2026-07-09",
+  effectiveAt: "2026-07-09T00:00:00.000Z",
+  models: {
+    ...RATE_CARD_2026_07_07.models,
+    // OpenAI GPT-5.6 Sol preview price: input $5.00/Mtok, cache writes
+    // $6.25/Mtok, cached reads $0.50/Mtok, and output $30.00/Mtok. Source
+    // (verified 2026-07-09):
+    // https://help.openai.com/en/articles/20001325-a-preview-of-gpt-5-6-sol-terra-and-luna
+    "gpt-5.6-sol": openAiCacheWriteTier({
+      input: 5,
+      output: 30
+    })
+  }
+};
+var RATE_CARD_2026_07_30 = {
+  version: "2026-07-30",
+  effectiveAt: "2026-07-30T00:00:00.000Z",
+  models: {
+    ...RATE_CARD_2026_07_09.models,
+    "gpt-5.6-terra": openAiLongContextTier({
+      input: 2,
+      output: 12
+    }),
+    "gpt-5.6-luna": openAiLongContextTier({
+      input: 0.2,
+      output: 1.2
+    })
+  }
+};
+var RATE_CARD_2026_09_01 = {
+  version: "2026-09-01",
+  effectiveAt: "2026-09-01T00:00:00.000Z",
+  models: {
+    ...RATE_CARD_2026_07_30.models,
+    "claude-fable-5-1": fable51Tier(),
+    "claude-mythos-5-1": fable51Tier()
+  }
+};
+var RATE_CARD_2026_09_04 = {
+  version: "2026-09-04",
+  effectiveAt: "2026-09-04T00:00:00.000Z",
+  models: {
+    ...RATE_CARD_2026_09_01.models,
+    "gpt-6-astra": openAiLongContextTier({
+      input: 10,
+      output: 50
+    })
+  }
+};
+var PRICING_RATE_CARDS = {
+  [RATE_CARD_2026_06_23.version]: RATE_CARD_2026_06_23,
+  [RATE_CARD_2026_07_04.version]: RATE_CARD_2026_07_04,
+  [RATE_CARD_2026_07_07.version]: RATE_CARD_2026_07_07,
+  [RATE_CARD_2026_07_09.version]: RATE_CARD_2026_07_09,
+  [RATE_CARD_2026_07_30.version]: RATE_CARD_2026_07_30,
+  [RATE_CARD_2026_09_01.version]: RATE_CARD_2026_09_01,
+  [RATE_CARD_2026_09_04.version]: RATE_CARD_2026_09_04
+};
+var CURRENT_PRICING_VERSION = RATE_CARD_2026_09_04.version;
+function getModelPricing(model, pricingVersion = CURRENT_PRICING_VERSION) {
+  const card = PRICING_RATE_CARDS[pricingVersion];
+  if (!card) {
+    throw new UnknownPricingVersionError(pricingVersion);
+  }
+  const pricing = card.models[model];
+  if (!pricing) {
+    throw new UnknownPricingModelError(model, pricingVersion);
+  }
+  return pricing;
+}
+function tier(inputUsdPerMtok, outputUsdPerMtok) {
+  return {
+    inputUsdPerMtok,
+    outputUsdPerMtok,
+    cacheWrite5mUsdPerMtok: inputUsdPerMtok * 1.25,
+    cacheReadUsdPerMtok: inputUsdPerMtok * 0.1
+  };
+}
+function opusTier() {
+  return tier(5, 25);
+}
+function fable51Tier() {
+  return {
+    ...tier(10, 50),
+    cacheReadUsdPerMtok: 0.25
+  };
+}
+function openAiTier(rates) {
+  return {
+    inputUsdPerMtok: rates.input,
+    outputUsdPerMtok: rates.output,
+    cacheWrite5mUsdPerMtok: rates.input,
+    cacheReadUsdPerMtok: rates.cachedInput
+  };
+}
+function openAiCacheWriteTier(rates) {
+  return {
+    inputUsdPerMtok: rates.input,
+    outputUsdPerMtok: rates.output,
+    cacheWrite5mUsdPerMtok: rates.input * 1.25,
+    cacheReadUsdPerMtok: rates.input * 0.1
+  };
+}
+function openAiLongContextTier(rates) {
+  return {
+    ...openAiCacheWriteTier(rates),
+    longContext: {
+      thresholdInputTokens: 272e3,
+      inputMultiplier: 2,
+      outputMultiplier: 1.5
+    }
+  };
+}
+
 // ../../packages/schemas/src/model-selection.ts
 var MODEL_API_TOKEN_PROVIDERS = [
   "anthropic",
@@ -35842,6 +36043,13 @@ var CODEX_MAX_REASONING_EFFORTS = [
   ...CODEX_REASONING_EFFORTS,
   "max"
 ];
+var CODEX_ASTRA_REASONING_EFFORTS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
 var ClaudeCodeReasoningEffortSchema = external_exports.enum(
   CLAUDE_CODE_REASONING_EFFORTS
 );
@@ -35894,6 +36102,2994 @@ var ModelRoutingConfigSchema = external_exports.object({
   // authored fields are mutually exclusive at validation).
   fallbackModelIds: external_exports.array(external_exports.string().min(1)).min(1).max(2).optional()
 }).strict();
+var InvalidModelSelectionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidModelSelectionError";
+  }
+};
+var HARNESS_MODEL_RULES = {
+  "claude-code": {
+    defaultProvider: "anthropic",
+    providers: ["anthropic"],
+    defaultModel: "claude-opus-4-8",
+    curatedModels: {
+      anthropic: [
+        "claude-opus-4-8",
+        "fable",
+        "claude-fable-5-1",
+        "claude-mythos-5-1",
+        "claude-fable-5",
+        "claude-opus-4-7",
+        "claude-opus-4-6",
+        "claude-sonnet-5",
+        "claude-sonnet-4-6",
+        "claude-haiku-4-5",
+        "claude-haiku-4-5-20251001"
+      ]
+    },
+    curatedModelMetadata: {
+      anthropic: {
+        fable: {
+          displayName: "Claude Fable 5.1",
+          availability: "generally_available"
+        },
+        "claude-fable-5-1": {
+          displayName: "Claude Fable 5.1",
+          availability: "generally_available"
+        },
+        "claude-mythos-5-1": {
+          displayName: "Claude Mythos 5.1",
+          availability: "limited_access",
+          availabilityLabel: "Project Glasswing"
+        }
+      }
+    },
+    openProviderPatterns: {},
+    // The pinned Claude Agent SDK applies "high" when the effort option is
+    // omitted, so "high" is what default-effort sessions have always run at.
+    defaultReasoningEffort: "high",
+    reasoningEfforts: CLAUDE_CODE_REASONING_EFFORTS,
+    reasoningEffortsByModel: {}
+  },
+  codex: {
+    defaultProvider: "openai",
+    providers: ["openai", "openrouter"],
+    defaultModel: "gpt-5.6-sol",
+    curatedModels: {
+      openai: [
+        "gpt-6-astra",
+        "gpt-5.6-sol",
+        "gpt-5.6-terra",
+        "gpt-5.6-luna",
+        "gpt-5.5",
+        "gpt-5.3-codex"
+      ]
+    },
+    curatedModelMetadata: {
+      openai: {
+        "gpt-6-astra": {
+          displayName: "GPT-6 Astra",
+          availability: "limited_access",
+          availabilityLabel: "Trusted Access Program"
+        }
+      }
+    },
+    openProviderPatterns: {
+      openrouter: OPENROUTER_MODEL_SLUG_PATTERN
+    },
+    defaultReasoningEffort: "medium",
+    reasoningEfforts: CODEX_REASONING_EFFORTS,
+    reasoningEffortsByModel: {
+      openai: {
+        "gpt-6-astra": {
+          defaultEffort: "medium",
+          efforts: CODEX_ASTRA_REASONING_EFFORTS
+        },
+        "gpt-5.6-sol": {
+          defaultEffort: "medium",
+          efforts: CODEX_MAX_REASONING_EFFORTS
+        },
+        "gpt-5.6-terra": {
+          defaultEffort: "medium",
+          efforts: CODEX_MAX_REASONING_EFFORTS
+        },
+        "gpt-5.6-luna": {
+          defaultEffort: "medium",
+          efforts: CODEX_MAX_REASONING_EFFORTS
+        },
+        "gpt-5.5": {
+          defaultEffort: "medium",
+          efforts: CODEX_REASONING_EFFORTS
+        },
+        "gpt-5.3-codex": {
+          defaultEffort: "medium",
+          efforts: CODEX_REASONING_EFFORTS
+        }
+      },
+      openrouter: {
+        "moonshotai/kimi-k3": {
+          defaultEffort: "high",
+          efforts: ["high", "xhigh"]
+        },
+        "z-ai/glm-5.2": {
+          defaultEffort: "high",
+          efforts: ["high", "xhigh"]
+        },
+        "x-ai/grok-4.5": {
+          defaultEffort: "high",
+          efforts: ["medium", "high"]
+        },
+        "anthropic/claude-sonnet-5": {
+          defaultEffort: "medium",
+          efforts: ["low", "medium", "high", "xhigh"]
+        },
+        "moonshotai/kimi-k2.7-code": {
+          defaultEffort: "high",
+          efforts: ["high", "xhigh"]
+        }
+      }
+    }
+  }
+};
+function modelRulesForHarness(harness) {
+  return HARNESS_MODEL_RULES[harness];
+}
+var MODEL_WIRE_ID_ALIASES = {
+  fable: "claude-fable-5-1"
+};
+function resolveModelWireId(id) {
+  return MODEL_WIRE_ID_ALIASES[id] ?? id;
+}
+function reasoningEffortRulesForModelSelection(input) {
+  const rules = modelRulesForHarness(input.harness);
+  const model = resolveModelSelectionForHarness(input.harness, input.model);
+  return rules.reasoningEffortsByModel[model.provider]?.[model.id] ?? {
+    defaultEffort: rules.defaultReasoningEffort,
+    efforts: rules.reasoningEfforts
+  };
+}
+function resolveModelSelectionForHarness(harness, selection) {
+  const rules = modelRulesForHarness(harness);
+  const provider = selection?.provider ?? rules.defaultProvider;
+  const id = selection?.id ?? rules.defaultModel;
+  validateModelProviderForHarness(harness, provider);
+  validateModelIdForProvider({ harness, provider, id });
+  return { provider, id };
+}
+function validateReasoningEffortForHarness(input) {
+  if (!input.reasoningEffort) {
+    return;
+  }
+  const rules = reasoningEffortRulesForModelSelection({
+    harness: input.harness,
+    model: input.model
+  });
+  if (!rules.efforts.includes(input.reasoningEffort)) {
+    throw new InvalidModelSelectionError(
+      `${input.harness} does not support reasoning effort "${input.reasoningEffort}"`
+    );
+  }
+}
+function validateAgentModelOpenRouterForHarness(spec, context) {
+  const openrouter = spec.model?.openrouter;
+  if (!openrouter) {
+    return;
+  }
+  if (spec.resolvedModel?.provider !== "openrouter") {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["model", "openrouter"],
+      message: `model.openrouter is only valid when the resolved provider is openrouter (got ${spec.resolvedModel?.provider ?? "none"})`
+    });
+    return;
+  }
+  const primaryId = spec.resolvedModel.id;
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, id] of openrouter.models.entries()) {
+    if (id === primaryId) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["model", "openrouter", "models", index],
+        message: "model.openrouter.models must not include the primary model id (it is prepended automatically)"
+      });
+      return;
+    }
+    if (seen.has(id)) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["model", "openrouter", "models", index],
+        message: "model.openrouter.models must not contain duplicate entries"
+      });
+      return;
+    }
+    seen.add(id);
+  }
+}
+function validateAgentModelFallbacksForHarness(spec, context) {
+  const fallbacks = spec.model?.fallbacks;
+  if (!fallbacks || fallbacks.length === 0) {
+    return;
+  }
+  if (spec.model?.openrouter) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["model", "fallbacks"],
+      message: "model.fallbacks and model.openrouter cannot be combined"
+    });
+    return;
+  }
+  const primary = spec.resolvedModel;
+  if (!primary) {
+    return;
+  }
+  const seenIds = /* @__PURE__ */ new Set([primary.id]);
+  for (const [index, fallback] of fallbacks.entries()) {
+    let resolved;
+    try {
+      resolved = resolveModelSelectionForHarness(spec.harness, {
+        provider: fallback.provider ?? primary.provider,
+        id: fallback.id
+      });
+    } catch (error51) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["model", "fallbacks", index],
+        message: error51 instanceof Error ? error51.message : String(error51)
+      });
+      continue;
+    }
+    if (resolved.provider !== primary.provider) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["model", "fallbacks", index, "provider"],
+        message: `model.fallbacks entries must resolve to the primary's provider (${primary.provider}); got ${resolved.provider}`
+      });
+      continue;
+    }
+    if (seenIds.has(resolved.id)) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["model", "fallbacks", index, "id"],
+        message: "model.fallbacks ids must be distinct and must not repeat the primary model id"
+      });
+      continue;
+    }
+    seenIds.add(resolved.id);
+    try {
+      validateReasoningEffortForHarness({
+        harness: spec.harness,
+        model: resolved,
+        reasoningEffort: spec.reasoningEffort
+      });
+    } catch (error51) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["model", "fallbacks", index],
+        message: error51 instanceof Error ? error51.message : String(error51)
+      });
+    }
+  }
+}
+function validateAgentModelFieldsForHarness(spec, context) {
+  const harness = spec.harness;
+  if (harness !== "claude-code" && harness !== "codex") {
+    return;
+  }
+  let resolvedModel;
+  try {
+    resolvedModel = resolveModelSelectionForHarness(harness, spec.model);
+  } catch (error51) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["model"],
+      message: error51 instanceof Error ? error51.message : String(error51)
+    });
+  }
+  try {
+    validateReasoningEffortForHarness({
+      harness,
+      model: resolvedModel,
+      reasoningEffort: spec.reasoningEffort
+    });
+  } catch (error51) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["reasoningEffort"],
+      message: error51 instanceof Error ? error51.message : String(error51)
+    });
+  }
+  validateAgentModelOpenRouterForHarness(
+    { harness, model: spec.model, resolvedModel },
+    context
+  );
+  validateAgentModelFallbacksForHarness(
+    {
+      harness,
+      model: spec.model,
+      reasoningEffort: spec.reasoningEffort,
+      resolvedModel
+    },
+    context
+  );
+}
+function validateModelProviderForHarness(harness, provider) {
+  const rules = modelRulesForHarness(harness);
+  if (!rules.providers.includes(provider)) {
+    throw new InvalidModelSelectionError(
+      `${harness} does not support ${provider} models`
+    );
+  }
+}
+function validateModelIdForProvider(input) {
+  const rules = modelRulesForHarness(input.harness);
+  const curated = rules.curatedModels[input.provider];
+  if (curated?.includes(input.id)) {
+    validatePricingForClosedProviderSelection(input);
+    return;
+  }
+  const pattern = rules.openProviderPatterns[input.provider];
+  if (pattern?.test(input.id)) {
+    return;
+  }
+  if (curated) {
+    throw new InvalidModelSelectionError(
+      `${input.provider} model "${input.id}" is not available for ${input.harness}`
+    );
+  }
+  throw new InvalidModelSelectionError(
+    `${input.provider} model ids are not open for ${input.harness}`
+  );
+}
+function validatePricingForClosedProviderSelection(input) {
+  if (input.provider === "openrouter") {
+    return;
+  }
+  try {
+    getModelPricing(resolveModelWireId(input.id));
+  } catch (error51) {
+    if (error51 instanceof UnknownPricingModelError || error51 instanceof UnknownPricingVersionError) {
+      throw new InvalidModelSelectionError(
+        `${input.provider} model "${input.id}" cannot be scheduled for ${input.harness} without current pricing`
+      );
+    }
+    throw error51;
+  }
+}
+
+// ../../packages/schemas/src/resources.ts
+var ResourceNameSchema = external_exports.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_.-]+$/);
+var StringMapSchema = external_exports.record(external_exports.string().min(1), external_exports.string());
+var MetadataInputSchema = external_exports.object({
+  name: ResourceNameSchema,
+  labels: StringMapSchema.optional(),
+  annotations: StringMapSchema.optional()
+});
+var MetadataSchema = MetadataInputSchema.extend({
+  uid: OpaqueIdSchema2,
+  generation: external_exports.number().int().positive(),
+  resourceVersion: external_exports.string().min(1),
+  createdAt: external_exports.string().datetime(),
+  updatedAt: external_exports.string().datetime()
+});
+function resourceEnvelopeSchema(spec) {
+  return external_exports.object({
+    metadata: MetadataSchema,
+    spec
+  });
+}
+function resourceApplySchema(spec) {
+  return external_exports.object({
+    metadata: MetadataInputSchema,
+    spec
+  });
+}
+
+// ../../packages/schemas/src/connections.ts
+var ConnectionNameSchema = ResourceNameSchema;
+var ProviderConnectionReferenceSchema = external_exports.object({
+  provider: ProviderNameSchema,
+  connection: ConnectionNameSchema
+});
+var ProjectConnectionAllocationSpecSchema = external_exports.object({
+  provider: ProviderNameSchema
+});
+var ProjectConnectionAllocationResourceSchema = resourceEnvelopeSchema(
+  ProjectConnectionAllocationSpecSchema
+);
+var GithubConnectionAccountSchema = external_exports.object({
+  login: external_exports.string().trim().min(1),
+  type: external_exports.enum(["User", "Organization"])
+});
+var GithubConnectionRepositorySchema = external_exports.object({
+  id: external_exports.number().int().positive().optional(),
+  fullName: external_exports.string().trim().min(1)
+});
+var GITHUB_CONNECTION_EVENTS = [
+  "installation",
+  "installation_repositories",
+  "push",
+  "pull_request",
+  "check_run",
+  "issues",
+  "issue_comment",
+  "pull_request_review",
+  "pull_request_review_comment",
+  "pull_request_review_thread",
+  // `workflow_run` fires when a GitHub Actions run completes. Auto ingests
+  // only `action=completed` as `github.workflow_run.completed` — the general
+  // "CI on main finished" primitive that `check_run.completed` cannot cover
+  // because check runs hard-require PR association.
+  "workflow_run",
+  // `commit_comment` fires on a new comment attached to a commit (the
+  // quickstart deploy comment that carries the site URL). Auto ingests only
+  // `action=created` as `github.commit_comment.created`.
+  "commit_comment"
+];
+var GithubConnectionEventSchema = external_exports.enum(GITHUB_CONNECTION_EVENTS);
+var GithubConnectionSpecSchema = external_exports.object({
+  provider: external_exports.literal("github"),
+  installationId: external_exports.string().trim().min(1),
+  account: GithubConnectionAccountSchema,
+  repositorySelection: external_exports.enum(["all", "selected"]).default("all"),
+  repositories: external_exports.array(GithubConnectionRepositorySchema).default([]),
+  events: external_exports.array(GithubConnectionEventSchema).min(1).default(["pull_request"])
+});
+var ConnectionSpecSchema = GithubConnectionSpecSchema;
+var ConnectionResourceSchema = resourceEnvelopeSchema(ConnectionSpecSchema);
+var ConnectionApplyRequestSchema = resourceApplySchema(ConnectionSpecSchema);
+var ConnectionStartReturnToSchema = external_exports.enum([
+  "onboarding",
+  "connections"
+]);
+var GithubRepositoryPickerDestinationSchema = external_exports.enum([
+  "settings",
+  "onboarding",
+  "sessions",
+  "agents"
+]);
+var GithubRepositoryPickerContinuationSchema = external_exports.object({
+  organizationId: OrganizationIdSchema,
+  projectId: ProjectIdSchema,
+  destination: GithubRepositoryPickerDestinationSchema
+});
+var ConnectionStartRequestSchema = external_exports.object({
+  organizationId: OrganizationIdSchema.optional(),
+  provider: ProviderNameSchema,
+  allowProjectId: ProjectIdSchema.optional(),
+  returnTo: ConnectionStartReturnToSchema.optional(),
+  githubRepositoryPickerDestination: GithubRepositoryPickerDestinationSchema.optional(),
+  replace: external_exports.object({
+    connection: ConnectionNameSchema,
+    removeFirst: external_exports.boolean().default(false)
+  }).optional()
+}).superRefine((value, context) => {
+  if (value.githubRepositoryPickerDestination && (value.provider !== "github" || !value.allowProjectId)) {
+    context.addIssue({
+      code: "custom",
+      message: "GitHub repository picker continuations require a GitHub project connection",
+      path: ["githubRepositoryPickerDestination"]
+    });
+  }
+});
+var ConnectionProviderDescriptorSchema = external_exports.object({
+  provider: ProviderNameSchema,
+  displayName: external_exports.string().trim().min(1),
+  credentialKind: ProviderCredentialKindSchema,
+  oauthManualRedirectSetup: external_exports.object({
+    mode: external_exports.enum(["self_service", "provider_approval"]),
+    explanation: external_exports.string().trim().min(1),
+    instructions: external_exports.array(external_exports.string().trim().min(1)).min(1),
+    callbackUrl: external_exports.string().trim().url(),
+    documentationAction: external_exports.object({
+      label: external_exports.string().trim().min(1),
+      url: external_exports.string().trim().url()
+    }),
+    settingsAction: external_exports.object({
+      label: external_exports.string().trim().min(1),
+      url: external_exports.string().trim().url()
+    }).optional()
+  }).optional()
+});
+var ConnectionProviderListResponseSchema = external_exports.object({
+  providers: external_exports.array(ConnectionProviderDescriptorSchema)
+});
+var ConnectionStartResponseSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({
+    status: external_exports.literal("authorization_required"),
+    provider: ProviderNameSchema,
+    authorizationUrl: external_exports.string().trim().url(),
+    message: external_exports.string().trim().min(1)
+  }),
+  external_exports.object({
+    status: external_exports.literal("not_implemented"),
+    provider: ProviderNameSchema,
+    message: external_exports.string().trim().min(1)
+  }),
+  // Providers with no OAuth (Telegram): the user completes manual provider-side
+  // steps, then submits the resulting token to the provider's connection
+  // endpoint. `steps` is ordered, human-readable wizard guidance.
+  external_exports.object({
+    status: external_exports.literal("token_required"),
+    provider: ProviderNameSchema,
+    message: external_exports.string().trim().min(1),
+    steps: external_exports.array(external_exports.string().trim().min(1)).min(1)
+  })
+]);
+var TelegramConnectionCreateRequestSchema = external_exports.object({
+  organizationId: OrganizationIdSchema.optional(),
+  token: external_exports.string().trim().min(1),
+  name: ConnectionNameSchema.optional(),
+  validateOnly: external_exports.boolean().default(false),
+  /** Grant this project access to the connection once created. */
+  allowProjectId: ProjectIdSchema.optional()
+});
+var TelegramManagerBotSummarySchema = external_exports.object({
+  botUserId: external_exports.string().trim().min(1),
+  botUsername: external_exports.string().trim().min(1),
+  botName: external_exports.string().trim().min(1)
+});
+var TelegramConnectionCreateResponseSchema = external_exports.discriminatedUnion(
+  "status",
+  [
+    external_exports.object({
+      status: external_exports.literal("invalid_token"),
+      message: external_exports.string().trim().min(1)
+    }),
+    external_exports.object({
+      status: external_exports.literal("management_mode_disabled"),
+      manager: TelegramManagerBotSummarySchema,
+      message: external_exports.string().trim().min(1)
+    }),
+    external_exports.object({
+      status: external_exports.literal("validated"),
+      manager: TelegramManagerBotSummarySchema,
+      message: external_exports.string().trim().min(1)
+    }),
+    external_exports.object({
+      status: external_exports.literal("connected"),
+      connection: ConnectionNameSchema,
+      manager: TelegramManagerBotSummarySchema,
+      organizationId: OrganizationIdSchema,
+      message: external_exports.string().trim().min(1)
+    })
+  ]
+);
+var ModelProviderConnectionCreateRequestSchema = external_exports.object({
+  organizationId: OrganizationIdSchema.optional(),
+  provider: ModelApiTokenProviderSchema,
+  token: external_exports.string().trim().min(1),
+  name: ConnectionNameSchema.default("default"),
+  /** Grant this project access to the connection once created. */
+  allowProjectId: ProjectIdSchema.optional()
+});
+var ModelProviderConnectionCreateResponseSchema = external_exports.object({
+  status: external_exports.literal("connected"),
+  provider: ModelApiTokenProviderSchema,
+  connection: ConnectionNameSchema,
+  providerGrantId: external_exports.string().trim().min(1),
+  organizationId: OrganizationIdSchema,
+  message: external_exports.string().trim().min(1)
+});
+var ConnectionAllowRequestSchema = external_exports.object({
+  organizationId: OrganizationIdSchema.optional(),
+  provider: ProviderNameSchema,
+  projectId: ProjectIdSchema,
+  connection: ConnectionNameSchema.optional()
+});
+var SlackConfigTokenRegisterRequestSchema = external_exports.object({
+  connection: ConnectionNameSchema.optional(),
+  workspace: external_exports.string().trim().min(1).optional(),
+  refreshToken: external_exports.string().trim().min(1)
+});
+var SlackConfigTokenRegisterResponseSchema = external_exports.object({
+  status: external_exports.literal("registered"),
+  connection: ConnectionNameSchema,
+  workspace: external_exports.string().trim().min(1),
+  expiresAt: external_exports.string().datetime()
+});
+var ConnectionAllowResponseSchema = external_exports.object({
+  status: external_exports.literal("allocated"),
+  provider: ProviderNameSchema,
+  projectId: ProjectIdSchema,
+  connection: ConnectionNameSchema,
+  providerGrantId: external_exports.string().trim().min(1),
+  message: external_exports.string().trim().min(1)
+});
+var ConnectionRemoveRequestSchema = external_exports.object({
+  organizationId: OrganizationIdSchema.optional(),
+  provider: ProviderNameSchema,
+  connection: ConnectionNameSchema
+});
+var ConnectionRemoveResponseSchema = external_exports.object({
+  status: external_exports.literal("removed"),
+  provider: ProviderNameSchema,
+  connection: ConnectionNameSchema,
+  providerGrantId: external_exports.string().trim().min(1),
+  message: external_exports.string().trim().min(1)
+});
+
+// ../../packages/schemas/src/mounts.ts
+var AbsoluteMountPathSchema = external_exports.string().trim().min(1).refine((value) => value.startsWith("/"), {
+  message: "Mount paths must be absolute"
+});
+var GITHUB_MOUNT_CAPABILITY_LEVELS = [
+  "none",
+  "read",
+  "write"
+];
+var GithubMountCapabilityLevelSchema = external_exports.enum(
+  GITHUB_MOUNT_CAPABILITY_LEVELS
+);
+var GithubMountCapabilitySchema = external_exports.union([
+  GithubMountCapabilityLevelSchema,
+  external_exports.object({
+    level: GithubMountCapabilityLevelSchema,
+    unattributed: GithubMountCapabilityLevelSchema
+  }).strict().superRefine((capability, context) => {
+    if (!capabilityLevelAtMost({
+      floor: capability.unattributed,
+      grant: capability.level,
+      levels: GITHUB_MOUNT_CAPABILITY_LEVELS
+    })) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        message: "unattributed capability level must not exceed level",
+        path: ["unattributed"]
+      });
+    }
+  })
+]);
+var GITHUB_MOUNT_MERGE_CAPABILITY_LEVELS = ["none", "write"];
+var GithubMountMergeCapabilityLevelSchema = external_exports.enum(
+  GITHUB_MOUNT_MERGE_CAPABILITY_LEVELS
+);
+var GithubMountMergeCapabilitySchema = external_exports.union([
+  GithubMountMergeCapabilityLevelSchema,
+  external_exports.object({
+    level: GithubMountMergeCapabilityLevelSchema,
+    unattributed: GithubMountMergeCapabilityLevelSchema
+  }).strict().superRefine((capability, context) => {
+    if (!capabilityLevelAtMost({
+      floor: capability.unattributed,
+      grant: capability.level,
+      levels: GITHUB_MOUNT_MERGE_CAPABILITY_LEVELS
+    })) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        message: "unattributed capability level must not exceed level",
+        path: ["unattributed"]
+      });
+    }
+  })
+]);
+var DEFAULT_GITHUB_MOUNT_CAPABILITIES = {
+  contents: "write",
+  pullRequests: "write",
+  issues: "write",
+  checks: "read",
+  actions: "read",
+  workflows: "none",
+  secrets: "none",
+  merge: "none"
+};
+var GitMountAuthSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    kind: external_exports.literal("none")
+  }),
+  external_exports.object({
+    kind: external_exports.literal("githubApp"),
+    installationId: external_exports.string().trim().min(1).optional(),
+    commitAuthor: external_exports.object({
+      name: external_exports.string().trim().min(1),
+      email: external_exports.string().trim().min(1).refine((value) => value.includes("@"), {
+        message: "Git commit author email must contain @"
+      })
+    }).optional(),
+    capabilities: external_exports.object({
+      contents: GithubMountCapabilitySchema.default("write"),
+      pullRequests: GithubMountCapabilitySchema.default("write"),
+      issues: GithubMountCapabilitySchema.default("write"),
+      checks: GithubMountCapabilitySchema.default("read"),
+      actions: GithubMountCapabilitySchema.default("read"),
+      workflows: GithubMountCapabilitySchema.default("none"),
+      // Grants the GitHub Actions secrets API (repository and environment
+      // secrets). Secret values are write-only on GitHub's side; read grants
+      // listing secret names, never values.
+      secrets: GithubMountCapabilitySchema.default("none"),
+      merge: GithubMountMergeCapabilitySchema.default("none")
+    }).strict().superRefine((capabilities, context) => {
+      if (grantedCapabilityLevel(capabilities.merge) === "write" && (grantedCapabilityLevel(capabilities.contents) !== "write" || grantedCapabilityLevel(capabilities.pullRequests) !== "write")) {
+        context.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "merge: write requires contents: write and pullRequests: write",
+          path: ["merge"]
+        });
+      }
+      const unattributed = effectiveGithubMountCapabilities(
+        capabilities,
+        false
+      );
+      if (unattributed.merge === "write" && (unattributed.contents !== "write" || unattributed.pullRequests !== "write")) {
+        context.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "unattributed merge: write requires unattributed contents: write and pullRequests: write",
+          path: ["merge"]
+        });
+      }
+    }).default({ ...DEFAULT_GITHUB_MOUNT_CAPABILITIES })
+  })
+]);
+var GitMountSchema = external_exports.object({
+  kind: external_exports.literal("git"),
+  repository: external_exports.string().trim().min(1),
+  mountPath: AbsoluteMountPathSchema,
+  ref: external_exports.string().trim().min(1).optional(),
+  depth: external_exports.number().int().positive().optional(),
+  auth: GitMountAuthSchema.default({
+    kind: "none"
+  })
+});
+var AgentMountSchema = external_exports.discriminatedUnion("kind", [GitMountSchema]);
+function effectiveGithubMountCapabilities(capabilities, requesterEligible) {
+  return {
+    actions: effectiveCapabilityLevel(capabilities.actions, requesterEligible),
+    checks: effectiveCapabilityLevel(capabilities.checks, requesterEligible),
+    contents: effectiveCapabilityLevel(
+      capabilities.contents,
+      requesterEligible
+    ),
+    issues: effectiveCapabilityLevel(capabilities.issues, requesterEligible),
+    merge: effectiveCapabilityLevel(capabilities.merge, requesterEligible),
+    pullRequests: effectiveCapabilityLevel(
+      capabilities.pullRequests,
+      requesterEligible
+    ),
+    secrets: effectiveCapabilityLevel(capabilities.secrets, requesterEligible),
+    workflows: effectiveCapabilityLevel(
+      capabilities.workflows,
+      requesterEligible
+    )
+  };
+}
+
+// ../../packages/schemas/src/github-sync.ts
+var GITHUB_SYNC_AUTO_PATH = ".auto";
+var GITHUB_SYNC_CI_WATCHDOG_DEFAULT_DELAY_MS = 15e3;
+var GithubSyncRepositoryFullNameSchema = external_exports.string().trim().min(1).regex(/^[^/\s]+\/[^/\s]+$/, {
+  message: "repository must be in owner/name form"
+});
+var GithubSyncProductionBranchSchema = external_exports.string().trim().min(1).max(255).refine((branch) => !branch.startsWith("/") && !branch.endsWith("/"), {
+  message: "branch must not start or end with /"
+});
+var GithubSyncCiWatchdogWorkflowSchema = external_exports.object({
+  workflowId: external_exports.string().trim().min(1).max(255)
+}).strict();
+var GithubSyncCiWatchdogSchema = external_exports.object({
+  workflows: external_exports.array(GithubSyncCiWatchdogWorkflowSchema).max(10).default([]),
+  checkDelayMs: external_exports.number().int().nonnegative().default(GITHUB_SYNC_CI_WATCHDOG_DEFAULT_DELAY_MS)
+}).strict();
+var GithubSyncBindingSchema = external_exports.object({
+  id: external_exports.string().trim().min(1),
+  organizationId: OrganizationIdSchema,
+  projectId: ProjectIdSchema,
+  providerGrantId: ProviderGrantIdSchema,
+  installationId: external_exports.string().trim().min(1),
+  repoFullName: GithubSyncRepositoryFullNameSchema,
+  repoId: external_exports.string().trim().min(1).nullable(),
+  productionBranch: GithubSyncProductionBranchSchema,
+  autoPath: external_exports.literal(GITHUB_SYNC_AUTO_PATH),
+  ciWatchdog: GithubSyncCiWatchdogSchema,
+  enabled: external_exports.boolean(),
+  lastPlannedSha: external_exports.string().trim().min(1).nullable(),
+  lastAppliedSha: external_exports.string().trim().min(1).nullable(),
+  createdAt: external_exports.string().datetime(),
+  updatedAt: external_exports.string().datetime()
+});
+var GithubSyncBindingCreateRequestSchema = external_exports.object({
+  connection: external_exports.string().trim().min(1).optional(),
+  repo: GithubSyncRepositoryFullNameSchema,
+  repoId: external_exports.string().trim().min(1).optional(),
+  branch: GithubSyncProductionBranchSchema.optional(),
+  ciWatchdog: GithubSyncCiWatchdogSchema.optional()
+});
+var GithubSyncInitialSyncSchema = external_exports.object({
+  started: external_exports.boolean(),
+  headSha: external_exports.string().trim().min(1).optional(),
+  workflowId: external_exports.string().trim().min(1).optional(),
+  reason: external_exports.enum([
+    "no_auto_directory",
+    "already_applied",
+    "probe_failed",
+    "start_failed"
+  ]).optional()
+});
+var GithubSyncBindingCreateResponseSchema = external_exports.object({
+  binding: GithubSyncBindingSchema,
+  created: external_exports.boolean(),
+  initialSync: GithubSyncInitialSyncSchema.optional()
+});
+var GithubSyncBindingListResponseSchema = external_exports.object({
+  bindings: external_exports.array(GithubSyncBindingSchema)
+});
+var GithubSyncBindingDisableResponseSchema = external_exports.object({
+  binding: GithubSyncBindingSchema.nullable()
+});
+var GithubSyncTriggerArtifactSchema = external_exports.object({
+  type: external_exports.string().trim().min(1),
+  externalId: external_exports.string().trim().min(1),
+  payload: JsonValueSchema2.optional()
+}).strict();
+var GithubSyncWorkflowInputSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    kind: external_exports.literal("pull_request"),
+    bindingId: external_exports.string().trim().min(1),
+    organizationId: OrganizationIdSchema,
+    projectId: ProjectIdSchema,
+    providerGrantId: ProviderGrantIdSchema,
+    installationId: external_exports.string().trim().min(1),
+    repoFullName: GithubSyncRepositoryFullNameSchema,
+    repoId: external_exports.string().trim().min(1).optional(),
+    productionBranch: GithubSyncProductionBranchSchema,
+    autoPath: external_exports.literal(GITHUB_SYNC_AUTO_PATH),
+    pullRequestNumber: external_exports.number().int().positive(),
+    headSha: external_exports.string().trim().min(1),
+    baseSha: external_exports.string().trim().min(1).optional(),
+    baseRef: GithubSyncProductionBranchSchema,
+    triggerArtifact: GithubSyncTriggerArtifactSchema.optional()
+  }),
+  external_exports.object({
+    kind: external_exports.literal("push"),
+    bindingId: external_exports.string().trim().min(1),
+    organizationId: OrganizationIdSchema,
+    projectId: ProjectIdSchema,
+    providerGrantId: ProviderGrantIdSchema,
+    installationId: external_exports.string().trim().min(1),
+    repoFullName: GithubSyncRepositoryFullNameSchema,
+    repoId: external_exports.string().trim().min(1).optional(),
+    productionBranch: GithubSyncProductionBranchSchema,
+    autoPath: external_exports.literal(GITHUB_SYNC_AUTO_PATH),
+    ref: external_exports.string().trim().min(1),
+    branch: GithubSyncProductionBranchSchema,
+    before: external_exports.string().trim().min(1).optional(),
+    after: external_exports.string().trim().min(1),
+    triggerArtifact: GithubSyncTriggerArtifactSchema.optional()
+  }),
+  // Synthetic re-apply triggered by a managed-template version bump (not a
+  // webhook). The tenant's `.auto` is unchanged — only our registry changed —
+  // so this arm skips the `no_auto_changes` early-out and applies the production
+  // branch HEAD (`after`, which the sweep resolves before starting the run).
+  // It is otherwise push-shaped. New waves carry the complete bounded
+  // `templates` set plus a deterministic `waveId`; legacy single-template
+  // coordinates remain accepted only so in-flight workflows can replay.
+  external_exports.object({
+    kind: external_exports.literal("template_push"),
+    bindingId: external_exports.string().trim().min(1),
+    organizationId: OrganizationIdSchema,
+    projectId: ProjectIdSchema,
+    providerGrantId: ProviderGrantIdSchema,
+    installationId: external_exports.string().trim().min(1),
+    repoFullName: GithubSyncRepositoryFullNameSchema,
+    repoId: external_exports.string().trim().min(1).optional(),
+    productionBranch: GithubSyncProductionBranchSchema,
+    autoPath: external_exports.literal(GITHUB_SYNC_AUTO_PATH),
+    before: external_exports.string().trim().min(1).optional(),
+    after: external_exports.string().trim().min(1),
+    // Legacy single-template coordinates remain optional so in-flight
+    // workflows started by a pre-wave worker can finish after deployment.
+    templateName: external_exports.string().trim().min(1).optional(),
+    version: external_exports.string().trim().min(1).optional(),
+    waveId: external_exports.string().trim().min(1).optional(),
+    // A bounded operator repair can re-run an already-terminal wave without
+    // reusing its completed Temporal workflow or apply operation. Ordinary
+    // subscription sweeps omit this field.
+    retryAttempt: external_exports.number().int().positive().max(9).optional(),
+    templates: external_exports.array(
+      external_exports.object({
+        name: external_exports.string().trim().min(1),
+        version: external_exports.string().trim().min(1)
+      })
+    ).min(1).max(50).optional(),
+    triggerArtifact: GithubSyncTriggerArtifactSchema.optional()
+  }).superRefine((input, context) => {
+    const legacy = Boolean(input.templateName && input.version);
+    const wave = Boolean(input.waveId && input.templates);
+    if (legacy === wave) {
+      context.addIssue({
+        code: "custom",
+        message: "template_push requires exactly one of legacy templateName/version or waveId/templates"
+      });
+    }
+    if (input.retryAttempt && !wave) {
+      context.addIssue({
+        code: "custom",
+        message: "template_push retryAttempt requires waveId/templates"
+      });
+    }
+  }),
+  // Synthetic authoritative re-apply triggered by one durable connection
+  // lifecycle occurrence. The event id makes retries reuse the same workflow,
+  // while a later remove/re-allow occurrence can re-run at the same git SHA.
+  external_exports.object({
+    kind: external_exports.literal("connection_push"),
+    bindingId: external_exports.string().trim().min(1),
+    organizationId: OrganizationIdSchema,
+    projectId: ProjectIdSchema,
+    providerGrantId: ProviderGrantIdSchema,
+    installationId: external_exports.string().trim().min(1),
+    repoFullName: GithubSyncRepositoryFullNameSchema,
+    repoId: external_exports.string().trim().min(1).optional(),
+    productionBranch: GithubSyncProductionBranchSchema,
+    autoPath: external_exports.literal(GITHUB_SYNC_AUTO_PATH),
+    before: external_exports.string().trim().min(1).optional(),
+    after: external_exports.string().trim().min(1),
+    connectionEventId: external_exports.string().trim().min(1),
+    triggerArtifact: GithubSyncTriggerArtifactSchema.optional()
+  })
+]);
+var GithubSyncWorkflowResultSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({
+    status: external_exports.literal("skipped"),
+    reason: external_exports.string().trim().min(1)
+  }),
+  external_exports.object({
+    status: external_exports.literal("planned"),
+    changed: external_exports.boolean(),
+    checkRunId: external_exports.number().int().positive().optional()
+  }),
+  external_exports.object({
+    status: external_exports.literal("applied"),
+    changed: external_exports.boolean(),
+    checkRunId: external_exports.number().int().positive().optional()
+  }),
+  external_exports.object({
+    status: external_exports.literal("failed"),
+    message: external_exports.string().trim().min(1),
+    checkRunId: external_exports.number().int().positive().optional()
+  })
+]);
+
+// ../../packages/schemas/src/github-mcp-catalog.ts
+var GITHUB_MCP_TOOL_NAMES = [
+  "actions_get",
+  "actions_list",
+  "actions_run_trigger",
+  "add_comment_to_pending_review",
+  "add_issue_comment",
+  "add_reply_to_pull_request_comment",
+  "create_branch",
+  "create_or_update_file",
+  "create_pull_request",
+  "create_repository",
+  "delete_file",
+  "fork_repository",
+  "get_commit",
+  "get_file_contents",
+  "get_job_logs",
+  "get_label",
+  "get_latest_release",
+  "get_release_by_tag",
+  "get_tag",
+  "issue_read",
+  "issue_write",
+  "list_branches",
+  "list_commits",
+  "list_issue_types",
+  "list_issues",
+  "list_pull_requests",
+  "list_releases",
+  "list_repository_collaborators",
+  "list_tags",
+  "merge_pull_request",
+  "pull_request_read",
+  "pull_request_review_write",
+  "push_files",
+  "search_code",
+  "search_commits",
+  "search_issues",
+  "search_pull_requests",
+  "search_repositories",
+  "sub_issue_write",
+  "update_pull_request",
+  "update_pull_request_branch"
+];
+var GITHUB_MCP_PROXY_TOOL_NAMES = [
+  "actions_secret_list",
+  "actions_secret_write",
+  "delete_issue_comment",
+  "download_comment_attachment",
+  "enable_pull_request_auto_merge",
+  "enqueue_pull_request",
+  "rerun_failed_jobs",
+  "rerun_failed_jobs_for_pr_head",
+  "upsert_issue_comment"
+];
+var GITHUB_MCP_SELECTABLE_TOOL_NAMES = [
+  ...GITHUB_MCP_TOOL_NAMES,
+  ...GITHUB_MCP_PROXY_TOOL_NAMES
+];
+var GITHUB_MCP_MERGE_TOOLS = [
+  "merge_pull_request",
+  "enable_pull_request_auto_merge",
+  "enqueue_pull_request"
+];
+var GITHUB_MCP_SECRETS_TOOLS = [
+  "actions_secret_list",
+  "actions_secret_write"
+];
+var GITHUB_MCP_SECRETS_WRITE_TOOLS = [
+  "actions_secret_write"
+];
+var GITHUB_MCP_ACTIONS_WRITE_TOOLS = [
+  "rerun_failed_jobs",
+  "rerun_failed_jobs_for_pr_head"
+];
+var GITHUB_MCP_WRITE_TOOLS = [
+  "actions_run_trigger",
+  "add_comment_to_pending_review",
+  "add_issue_comment",
+  "add_reply_to_pull_request_comment",
+  "create_branch",
+  "create_or_update_file",
+  "create_pull_request",
+  "create_repository",
+  "delete_file",
+  "fork_repository",
+  "issue_write",
+  "merge_pull_request",
+  "pull_request_review_write",
+  "push_files",
+  "sub_issue_write",
+  "update_pull_request",
+  "update_pull_request_branch"
+];
+var githubMcpToolNameSet = new Set(
+  GITHUB_MCP_TOOL_NAMES
+);
+var GITHUB_MCP_ATTRIBUTION_EXEMPT_PROXY_TOOLS = /* @__PURE__ */ new Set([
+  "actions_secret_list",
+  "download_comment_attachment",
+  "delete_issue_comment"
+]);
+var githubMcpWriteToolSet = /* @__PURE__ */ new Set([
+  ...GITHUB_MCP_WRITE_TOOLS,
+  ...GITHUB_MCP_PROXY_TOOL_NAMES.filter(
+    (name) => !GITHUB_MCP_ATTRIBUTION_EXEMPT_PROXY_TOOLS.has(name)
+  )
+]);
+var githubMcpProxyToolSet = new Set(
+  GITHUB_MCP_PROXY_TOOL_NAMES
+);
+var githubMcpMergeToolSet = new Set(
+  GITHUB_MCP_MERGE_TOOLS
+);
+var githubMcpSecretsToolSet = new Set(
+  GITHUB_MCP_SECRETS_TOOLS
+);
+var githubMcpSecretsWriteToolSet = new Set(
+  GITHUB_MCP_SECRETS_WRITE_TOOLS
+);
+var githubMcpActionsWriteToolSet = new Set(
+  GITHUB_MCP_ACTIONS_WRITE_TOOLS
+);
+
+// ../../packages/schemas/src/secrets.ts
+var SECRET_ENCRYPTION_ALGORITHM = "AES-256-GCM";
+var SecretEnvNameSchema = external_exports.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+var SecretCiphertextFieldSchema = external_exports.string().trim().min(1).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/);
+var SecretAesGcmIvSchema = external_exports.string().trim().regex(/^[A-Za-z0-9+/]{16}$/);
+var SecretAesGcmAuthTagSchema = external_exports.string().trim().regex(/^[A-Za-z0-9+/]{22}==$/);
+var SecretEnvValueSchema = external_exports.union([
+  external_exports.string(),
+  external_exports.object({
+    $secret: ResourceNameSchema,
+    optional: external_exports.boolean().optional()
+  })
+]);
+var SecretEnvSchema = external_exports.record(
+  SecretEnvNameSchema,
+  SecretEnvValueSchema
+);
+var EncryptedSecretValueSchema = external_exports.object({
+  keyVersion: external_exports.string().trim().min(1),
+  algorithm: external_exports.literal(SECRET_ENCRYPTION_ALGORITHM),
+  ciphertext: SecretCiphertextFieldSchema,
+  valueIv: SecretAesGcmIvSchema,
+  valueAuthTag: SecretAesGcmAuthTagSchema,
+  encryptedDek: SecretCiphertextFieldSchema,
+  dekIv: SecretAesGcmIvSchema,
+  dekAuthTag: SecretAesGcmAuthTagSchema
+});
+var SecretDescriptionSchema = external_exports.string().trim().max(1024);
+var SECRET_IDLE_EXPIRY_MAX_SECONDS = 10 * 365 * 24 * 60 * 60;
+var SecretExpiresAtSchema = external_exports.string().datetime({ offset: true });
+var SecretIdleExpirySecondsSchema = external_exports.number().int().min(1).max(SECRET_IDLE_EXPIRY_MAX_SECONDS);
+var SECRET_INJECTION_HOST_PATTERN = /^(?=.{1,253}$)([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]([a-z0-9-]{0,61}[a-z0-9])?$/;
+var SECRET_INJECTION_HEADER_PATTERN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+var SECRET_INJECTION_FORBIDDEN_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "content-length",
+  "host",
+  "transfer-encoding"
+]);
+var SecretInjectionHostSchema = external_exports.string().trim().toLowerCase().regex(
+  SECRET_INJECTION_HOST_PATTERN,
+  "Injection hosts must be exact lowercase hostnames (no wildcards, schemes, ports, or paths)"
+);
+var SecretInjectionHeaderSchema = external_exports.string().trim().min(1).max(128).regex(SECRET_INJECTION_HEADER_PATTERN, "Invalid HTTP header name").refine(
+  (header) => !SECRET_INJECTION_FORBIDDEN_HEADERS.has(header.toLowerCase()),
+  "This header cannot carry an injected secret"
+);
+var SecretInjectionSchema = external_exports.object({
+  hosts: external_exports.array(SecretInjectionHostSchema).min(1).max(16),
+  header: SecretInjectionHeaderSchema,
+  format: external_exports.string().min(1).max(256).refine(
+    (format) => format.includes("{value}"),
+    "Injection format must contain the {value} placeholder"
+  ).optional()
+});
+var SecretSetRequestSchema = external_exports.object({
+  value: external_exports.string(),
+  description: SecretDescriptionSchema.nullable().optional(),
+  protected: external_exports.boolean().optional(),
+  injection: SecretInjectionSchema.nullable().optional(),
+  expiresAt: SecretExpiresAtSchema.nullable().optional(),
+  idleExpirySeconds: SecretIdleExpirySecondsSchema.nullable().optional()
+});
+var SecretExpiryUpdateRequestSchema = external_exports.object({
+  expiresAt: SecretExpiresAtSchema.nullable().optional(),
+  idleExpirySeconds: SecretIdleExpirySecondsSchema.nullable().optional()
+}).refine(
+  (input) => input.expiresAt !== void 0 || input.idleExpirySeconds !== void 0,
+  { message: "Provide expiresAt and/or idleExpirySeconds" }
+);
+var SecretRotateRequestSchema = external_exports.object({
+  value: external_exports.string()
+});
+var SecretMetadataSchema = external_exports.object({
+  id: external_exports.string().trim().min(1),
+  organizationId: external_exports.string().trim().min(1),
+  projectId: external_exports.string().trim().min(1).nullable(),
+  name: ResourceNameSchema,
+  description: external_exports.string().nullable(),
+  protected: external_exports.boolean(),
+  // Defaulted rather than required so a newer client parsing an older
+  // server's metadata (deploy skew) treats an absent injection as plain
+  // env delivery.
+  injection: SecretInjectionSchema.nullable().default(null),
+  createdAt: external_exports.string().datetime(),
+  updatedAt: external_exports.string().datetime(),
+  lastRotatedAt: external_exports.string().datetime().nullable(),
+  lastAccessedAt: external_exports.string().datetime().nullable(),
+  // Like injection, defaulted for deploy skew: an older server that never sends
+  // expiry fields parses as a secret that never expires.
+  expiresAt: external_exports.string().datetime().nullable().default(null),
+  idleExpirySeconds: external_exports.number().int().nullable().default(null),
+  // Computed server-side: true when expiresAt has passed or the secret has
+  // been unused past idleExpirySeconds. Expired secrets resolve as absent
+  // everywhere but stay listed so operators can see and delete them.
+  expired: external_exports.boolean().default(false)
+});
+var SecretSetResponseSchema = external_exports.object({
+  secret: SecretMetadataSchema
+});
+var SecretListResponseSchema = external_exports.object({
+  secrets: external_exports.array(SecretMetadataSchema)
+});
+var SecretDeleteResponseSchema = external_exports.object({
+  secret: SecretMetadataSchema
+});
+var SecretExpiryUpdateResponseSchema = external_exports.object({
+  secret: SecretMetadataSchema
+});
+var SecretRevealResponseSchema = external_exports.object({
+  secret: SecretMetadataSchema,
+  value: external_exports.string()
+});
+
+// ../../packages/schemas/src/persisted-agent-grammar.ts
+function normalizePersistedAgentGrammar(spec) {
+  const triggers = Array.isArray(spec.triggers) ? spec.triggers : [];
+  const session = record2(spec.session);
+  const legacyGrammar = triggers.some(triggerUsesLegacyGrammar) || bindingsUseLegacyGrammar(spec.bindings) || session?.observeSpawnedSessions !== void 0;
+  if (!legacyGrammar) {
+    return spec;
+  }
+  const bindings = normalizePersistedBindings({
+    bindings: spec.bindings,
+    observeSpawnedSessions: session?.observeSpawnedSessions !== false,
+    triggers
+  });
+  const normalizedSession = session ? Object.fromEntries(
+    Object.entries(session).filter(
+      ([key]) => key !== "observeSpawnedSessions"
+    )
+  ) : spec.session;
+  return {
+    ...spec,
+    bindings,
+    triggers: normalizePersistedTriggers(triggers, spec.bindings),
+    ...session ? { session: normalizedSession } : {}
+  };
+}
+function normalizePersistedBindings(input) {
+  const policies = /* @__PURE__ */ new Map();
+  const bindings = record2(input.bindings) ?? {};
+  for (const [storedTarget, value] of Object.entries(bindings)) {
+    const entry = record2(value);
+    const target = finalTarget(storedTarget);
+    if (!entry || !target) continue;
+    mergePolicy(policies, target, {
+      lifecycle: entry.lifecycle === "held" || entry.lifecycle === "agent" || entry.continuity === "agent" ? "agent" : "session",
+      bindOn: [
+        ...Array.isArray(entry.bindOn) ? entry.bindOn.filter(
+          (action) => typeof action === "string"
+        ) : [],
+        ...entry.bind === "onAttributedEvent" ? ["attribution"] : []
+      ]
+    });
+  }
+  for (const trigger of input.triggers) {
+    const candidate = record2(trigger);
+    const routing = record2(candidate?.routing);
+    if (!routing) continue;
+    const inline = record2(routing.bind);
+    const storedTarget = typeof inline?.target === "string" ? inline.target : typeof routing.target === "string" ? routing.target : null;
+    const target = storedTarget ? finalTarget(storedTarget) : null;
+    if (!target) continue;
+    const lifecycleSource = inline ?? routing;
+    mergePolicy(policies, target, {
+      lifecycle: lifecycleSource.lifecycle === "held" || lifecycleSource.lifecycle === "agent" || lifecycleSource.continuity === "agent" ? "agent" : "session",
+      bindOn: []
+    });
+  }
+  mergePolicy(policies, "chat.thread", {
+    lifecycle: "session",
+    bindOn: ["send"]
+  });
+  mergePolicy(policies, "auto.connection.authorization_attempt", {
+    lifecycle: "agent",
+    bindOn: ["authorization"]
+  });
+  if (input.observeSpawnedSessions) {
+    mergePolicy(policies, "auto.session", {
+      lifecycle: "session",
+      bindOn: ["spawn"]
+    });
+  }
+  return Object.fromEntries(
+    [...policies.entries()].map(([target, policy]) => [
+      target,
+      {
+        lifecycle: policy.lifecycle,
+        ...policy.bindOn.size > 0 ? { bindOn: [...policy.bindOn].sort() } : {}
+      }
+    ])
+  );
+}
+function normalizePersistedTriggers(triggers, bindings) {
+  const legacyMentionBinding = Object.entries(record2(bindings) ?? {}).some(
+    ([target, value]) => (target === "slack.thread" || target === "chat.thread") && record2(value)?.bind === "onMention"
+  );
+  return triggers.flatMap((trigger) => {
+    const candidate = record2(trigger);
+    const routing = record2(candidate?.routing);
+    if (!candidate || !routing) return [trigger];
+    if (routing.target === "auto.task" || record2(routing.bind)?.target === "auto.task") {
+      return [];
+    }
+    const events = triggerEvents(candidate);
+    const inlineMentionBinding = routing.kind === "deliver" && record2(routing.bind) !== null;
+    if (events.includes("chat.message.mentioned") && events.some((event) => event !== "chat.message.mentioned") && (legacyMentionBinding || inlineMentionBinding)) {
+      const mention = { ...candidate };
+      delete mention.events;
+      mention.event = "chat.message.mentioned";
+      const remaining = { ...candidate };
+      delete remaining.event;
+      remaining.events = events.filter(
+        (event) => event !== "chat.message.mentioned"
+      );
+      remaining.routing = inlineMentionBinding ? Object.fromEntries(
+        Object.entries(routing).filter(([key]) => key !== "bind")
+      ) : routing;
+      return [
+        normalizePersistedTrigger(mention, true),
+        normalizePersistedTrigger(remaining, false)
+      ];
+    }
+    return [
+      normalizePersistedTrigger(
+        candidate,
+        events.length === 1 && events[0] === "chat.message.mentioned" && (legacyMentionBinding || inlineMentionBinding)
+      )
+    ];
+  });
+}
+function normalizePersistedTrigger(trigger, mentionBinding) {
+  const routing = record2(trigger.routing);
+  if (!routing) return trigger;
+  if (routing.kind !== "spawn" && routing.kind !== "bind" && routing.kind !== "deliver" && routing.kind !== "deliverOrSpawn") {
+    return trigger;
+  }
+  const routeBy = record2(routing.routeBy);
+  if (routing.routeBy !== void 0 && (!routeBy || routeBy.kind !== "singleton" && routeBy.kind !== "ownedArtifact" && routeBy.kind !== "allLiveSessions" && routeBy.kind !== "allLiveRuns" && routeBy.kind !== "attributedSessions" && routeBy.kind !== "attributedRuns")) {
+    return trigger;
+  }
+  const { routing: _routing, ...normalized } = trigger;
+  const onUnmatched = onUnmatchedPolicy(routing.onUnmatched);
+  const events = triggerEvents(trigger);
+  const inlineBind = record2(routing.bind);
+  let route;
+  if (inlineBind && routing.kind !== "deliver") {
+    route = targetRoute(inlineBind.target, "spawn");
+  } else if (routing.kind === "spawn" && events.length > 0 && events.every((event) => event.startsWith("chat.message."))) {
+    route = targetRoute("chat.thread", "spawn");
+  } else if (routing.kind === "spawn") {
+    route = { to: "new" };
+  } else if (routing.kind === "bind") {
+    route = targetRoute(routing.target, onUnmatched);
+  } else {
+    if (routeBy?.kind === "allLiveSessions" || routeBy?.kind === "allLiveRuns") {
+      route = { to: "all" };
+    } else if (routeBy?.kind === "attributedSessions" || routeBy?.kind === "attributedRuns") {
+      route = targetRoute("chat.thread", onUnmatched);
+    } else if (routeBy?.kind === "ownedArtifact") {
+      route = targetRoute(routeBy.artifactType, onUnmatched);
+    } else if (mentionBinding && onUnmatched === "spawn") {
+      route = targetRoute("chat.thread", "spawn");
+    } else {
+      route = {
+        to: "slot",
+        onUnmatched: routing.kind === "deliverOrSpawn" ? "spawn" : onUnmatched
+      };
+    }
+  }
+  const effects = {};
+  if (routing.kind === "bind" && routing.release) {
+    effects.release = {
+      target: typeof routing.target === "string" ? finalTarget(routing.target) : routing.target
+    };
+  }
+  if (mentionBinding && !(record2(route.to)?.target === "chat.thread" && route.onUnmatched === "spawn")) {
+    effects.bind = { target: "chat.thread" };
+  }
+  const deliveryGuard = record2(routing.deliveryGuard);
+  const where = record2(normalized.where);
+  const persistedWhere = record2(route.to)?.target === "chat.thread" && where?.["$.auto.authored"] === void 0 ? { ...where ?? {}, "$.auto.authored": false } : normalized.where;
+  return {
+    ...normalized,
+    ...persistedWhere === void 0 ? {} : { where: persistedWhere },
+    route,
+    ...deliveryGuard?.kind === "managedCheckSuccess" && typeof deliveryGuard.check === "string" ? { guard: { managedCheckSuccess: deliveryGuard.check } } : {},
+    ...Object.keys(effects).length > 0 ? { effects } : {}
+  };
+}
+function targetRoute(target, onUnmatched) {
+  return {
+    to: { target: typeof target === "string" ? finalTarget(target) : target },
+    onUnmatched
+  };
+}
+function mergePolicy(policies, target, incoming) {
+  const current = policies.get(target);
+  policies.set(target, {
+    lifecycle: current?.lifecycle === "agent" || incoming.lifecycle === "agent" ? "agent" : "session",
+    bindOn: /* @__PURE__ */ new Set([...current?.bindOn ?? [], ...incoming.bindOn])
+  });
+}
+function triggerUsesLegacyGrammar(value) {
+  return record2(value)?.routing !== void 0;
+}
+function bindingsUseLegacyGrammar(value) {
+  const bindings = record2(value);
+  if (!bindings) return false;
+  return Object.entries(bindings).some(([target, value2]) => {
+    const entry = record2(value2);
+    return target === "slack.thread" || entry?.continuity !== void 0 || entry?.bind !== void 0 || entry?.context !== void 0 || entry?.eventContext !== void 0 || entry?.lifecycle === "manual" || entry?.lifecycle === "held";
+  });
+}
+function triggerEvents(trigger) {
+  if (Array.isArray(trigger.events)) {
+    return trigger.events.filter(
+      (event) => typeof event === "string"
+    );
+  }
+  return typeof trigger.event === "string" ? [trigger.event] : [];
+}
+function finalTarget(target) {
+  if (target === "auto.task" || target === "agent.singleton" || target === "chat.message") {
+    return null;
+  }
+  return target === "slack.thread" ? "chat.thread" : target;
+}
+function onUnmatchedPolicy(value) {
+  return value === "warn" || value === "error" || value === "spawn" || value === "drop" ? value : "drop";
+}
+function record2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+
+// ../../packages/schemas/src/session-bindings.ts
+var BINDING_TARGET_TYPES = [
+  "github.pull_request",
+  "github.issue",
+  "chat.thread",
+  "linear.issue",
+  "webhook.key",
+  "provider.entity",
+  "auto.connection.authorization_attempt",
+  "auto.session"
+];
+var PERSISTED_BINDING_TARGET_TYPES = [
+  "github.pull_request",
+  "github.issue",
+  "slack.thread",
+  "chat.thread",
+  "chat.message",
+  "agent.singleton",
+  "linear.issue",
+  "webhook.key",
+  "provider.entity",
+  "auto.connection.authorization_attempt",
+  "auto.session",
+  "auto.task"
+];
+var TRIGGER_BINDING_TARGET_TYPES = [
+  ...BINDING_TARGET_TYPES
+];
+var OWNER_RELEASABLE_HELD_BINDING_TARGET_TYPES = [
+  "auto.connection.authorization_attempt"
+];
+var SESSION_BINDING_SOURCES = [
+  "trigger_spawn",
+  "agent_tool",
+  "chat_send",
+  "system"
+];
+var SESSION_BINDING_STATUSES = ["active", "released"];
+var BINDING_LIFECYCLES = ["session", "agent"];
+var BINDING_BOUND_CAUSES = [
+  "spawn",
+  "trigger",
+  "attribution",
+  "holder",
+  "chat",
+  "authorization",
+  "system",
+  "takeover",
+  "legacy"
+];
+var BINDING_RELEASED_CAUSES = [
+  "session_terminal",
+  "target_terminal",
+  "holder",
+  "operator",
+  "takeover",
+  "legacy"
+];
+var SESSION_BINDING_RELEASE_POLICIES = ["manual", "held"];
+var SESSION_BINDING_CONTINUITIES = ["session", "agent"];
+var SESSION_BINDING_RELEASED_BY = [
+  "agent_tool",
+  "archive",
+  "complete",
+  "trigger_release",
+  "operator",
+  "takeover"
+];
+var PERSISTED_SESSION_BINDING_RELEASED_BY = [
+  ...SESSION_BINDING_RELEASED_BY,
+  "task_terminal"
+];
+var BindingTargetTypeSchema = external_exports.enum(BINDING_TARGET_TYPES);
+var PersistedBindingTargetTypeSchema = external_exports.enum(
+  PERSISTED_BINDING_TARGET_TYPES
+);
+var TriggerBindingTargetTypeSchema = external_exports.enum(
+  TRIGGER_BINDING_TARGET_TYPES
+);
+var OwnerReleasableHeldBindingTargetTypeSchema = external_exports.enum(
+  OWNER_RELEASABLE_HELD_BINDING_TARGET_TYPES
+);
+var SessionBindingSourceSchema = external_exports.enum(SESSION_BINDING_SOURCES);
+var SessionBindingStatusSchema = external_exports.enum(SESSION_BINDING_STATUSES);
+var BindingLifecycleSchema = external_exports.enum(BINDING_LIFECYCLES);
+var BindingBoundCauseSchema = external_exports.enum(BINDING_BOUND_CAUSES);
+var BindingReleasedCauseSchema = external_exports.enum(BINDING_RELEASED_CAUSES);
+var SessionBindingReleasePolicySchema = external_exports.enum(
+  SESSION_BINDING_RELEASE_POLICIES
+);
+var SessionBindingContinuitySchema = external_exports.enum(
+  SESSION_BINDING_CONTINUITIES
+);
+var SessionBindingReleasedBySchema = external_exports.enum(
+  SESSION_BINDING_RELEASED_BY
+);
+var PersistedSessionBindingReleasedBySchema = external_exports.enum(
+  PERSISTED_SESSION_BINDING_RELEASED_BY
+);
+var BindingTargetSchema = external_exports.object({
+  type: BindingTargetTypeSchema,
+  externalId: external_exports.string().min(1)
+});
+var BINDING_ACTIONS = [
+  "send",
+  "attribution",
+  "spawn",
+  "authorization"
+];
+var BindingActionSchema = external_exports.enum(BINDING_ACTIONS);
+var BINDING_ACTION_LEGAL_TARGETS = {
+  send: /* @__PURE__ */ new Set(["chat.thread"]),
+  attribution: /* @__PURE__ */ new Set(["github.pull_request"]),
+  spawn: /* @__PURE__ */ new Set(["auto.session"]),
+  authorization: /* @__PURE__ */ new Set([
+    "auto.connection.authorization_attempt"
+  ])
+};
+
+// ../../packages/schemas/src/work-provenance.ts
+var StableKeySchema = external_exports.string().trim().min(1).max(512);
+var SnapshotNameSchema = external_exports.string().trim().min(1).max(256);
+var SourceIdSchema = external_exports.string().trim().min(1).max(512);
+var principalBase = {
+  stableKey: StableKeySchema,
+  displayName: SnapshotNameSchema
+};
+var schedulePrincipalSchema = external_exports.object({
+  kind: external_exports.literal("schedule"),
+  ...principalBase,
+  scheduleId: SourceIdSchema,
+  agentResourceId: SourceIdSchema,
+  agentName: SnapshotNameSchema,
+  triggerId: SourceIdSchema.nullable().default(null),
+  triggerName: SnapshotNameSchema.nullable().default(null),
+  triggerOrdinal: external_exports.number().int().nonnegative(),
+  cron: external_exports.string().trim().min(1).max(512).nullable().default(null),
+  timezone: external_exports.string().trim().min(1).max(128).nullable().default(null)
+});
+var webhookPrincipalSchema = external_exports.object({
+  kind: external_exports.literal("webhook"),
+  ...principalBase,
+  endpointId: SourceIdSchema,
+  endpointName: SnapshotNameSchema.nullable().default(null)
+});
+var serviceAccountPrincipalSchema = external_exports.object({
+  kind: external_exports.literal("service_account"),
+  ...principalBase,
+  serviceAccountId: SourceIdSchema
+});
+var providerIntegrationPrincipalSchema = external_exports.object({
+  kind: external_exports.literal("provider_integration"),
+  ...principalBase,
+  provider: ProviderNameSchema,
+  connectionId: SourceIdSchema.nullable().default(null)
+});
+var systemPrincipalSchema = external_exports.object({
+  kind: external_exports.literal("system"),
+  ...principalBase,
+  systemId: SourceIdSchema
+});
+var agentPrincipalSchema = external_exports.object({
+  kind: external_exports.literal("agent"),
+  ...principalBase,
+  agentResourceId: SourceIdSchema,
+  agentName: SnapshotNameSchema,
+  sessionId: SessionIdSchema2
+});
+var AutomationPrincipalSchema = external_exports.discriminatedUnion("kind", [
+  schedulePrincipalSchema,
+  webhookPrincipalSchema,
+  serviceAccountPrincipalSchema,
+  providerIntegrationPrincipalSchema,
+  systemPrincipalSchema,
+  agentPrincipalSchema
+]);
+var AutomationPrincipalAuthoringSchema = external_exports.discriminatedUnion("kind", [
+  schedulePrincipalSchema.strict(),
+  webhookPrincipalSchema.strict(),
+  serviceAccountPrincipalSchema.strict(),
+  providerIntegrationPrincipalSchema.strict(),
+  systemPrincipalSchema.strict(),
+  agentPrincipalSchema.strict()
+]);
+var scheduleCauseSchema = external_exports.object({
+  kind: external_exports.literal("schedule"),
+  sourceEventId: SourceIdSchema,
+  scheduledAt: external_exports.string().datetime()
+});
+var childSessionCauseSchema = external_exports.object({
+  kind: external_exports.literal("child_session"),
+  sourceSessionId: SessionIdSchema2
+});
+var githubArtifactCauseSchema = external_exports.object({
+  kind: external_exports.literal("github_artifact"),
+  sourceEventId: SourceIdSchema,
+  sourceSessionId: SessionIdSchema2,
+  sourceBindingId: SourceIdSchema,
+  sourceArtifactAttributionId: SourceIdSchema
+});
+var WorkProvenanceCauseSchema = external_exports.discriminatedUnion("kind", [
+  scheduleCauseSchema,
+  childSessionCauseSchema,
+  githubArtifactCauseSchema
+]);
+var WorkProvenanceCauseAuthoringSchema = external_exports.discriminatedUnion("kind", [
+  scheduleCauseSchema.strict(),
+  childSessionCauseSchema.strict(),
+  githubArtifactCauseSchema.strict()
+]);
+var WorkProvenanceFields = {
+  version: external_exports.literal(1),
+  root: AutomationPrincipalSchema,
+  actor: AutomationPrincipalSchema,
+  cause: WorkProvenanceCauseSchema
+};
+var WorkProvenanceSchema = external_exports.object(WorkProvenanceFields);
+var WorkProvenanceAuthoringSchema = external_exports.object({
+  version: external_exports.literal(1),
+  root: AutomationPrincipalAuthoringSchema,
+  actor: AutomationPrincipalAuthoringSchema,
+  cause: WorkProvenanceCauseAuthoringSchema
+}).strict();
+
+// ../../packages/schemas/src/requester-spend.ts
+var ExactUsdSchema = external_exports.string().regex(
+  /^(0|[1-9]\d*)(\.\d{1,10})?$/,
+  "Expected an exact non-negative USD decimal"
+);
+var RequesterSpendOverrideInputSchema = external_exports.object({
+  active: external_exports.boolean(),
+  reason: external_exports.string().trim().min(1).max(500).nullable(),
+  expiresAt: external_exports.string().datetime().nullable()
+});
+var RequesterSpendUpdateRequestSchema = external_exports.object({
+  expectedVersion: external_exports.number().int().nonnegative().nullable(),
+  dailyLimitUsd: ExactUsdSchema.nullable(),
+  monthlyLimitUsd: ExactUsdSchema.nullable(),
+  override: RequesterSpendOverrideInputSchema
+});
+var RequesterSpendSourceSchema = external_exports.object({
+  sourceKey: external_exports.string().min(1),
+  provider: external_exports.string().min(1).nullable(),
+  externalId: external_exports.string().min(1).nullable(),
+  accountRef: external_exports.string().min(1).nullable(),
+  displayName: external_exports.string().min(1).nullable(),
+  avatarUrl: external_exports.string().url().nullable(),
+  automationActor: AutomationPrincipalSchema.nullable().optional(),
+  automationCauseKind: external_exports.enum(["schedule", "child_session", "github_artifact"]).nullable().optional(),
+  totalUsd: ExactUsdSchema,
+  dailyUsd: ExactUsdSchema,
+  monthlyUsd: ExactUsdSchema
+});
+var RequesterSpendOverrideStateSchema = external_exports.object({
+  active: external_exports.boolean(),
+  effective: external_exports.boolean(),
+  reason: external_exports.string().nullable(),
+  expiresAt: external_exports.string().datetime().nullable(),
+  setByUserId: external_exports.string().min(1).nullable(),
+  setAt: external_exports.string().datetime().nullable()
+});
+var RequesterSpendPeriodSchema = external_exports.object({
+  usageUsd: ExactUsdSchema,
+  limitUsd: ExactUsdSchema.nullable(),
+  resetsAt: external_exports.string().datetime(),
+  capped: external_exports.boolean()
+});
+var RequesterSpendRowSchema = external_exports.object({
+  kind: external_exports.enum(["user", "automation", "unattributed"]),
+  requesterKey: external_exports.string().min(1),
+  requesterUserId: external_exports.string().min(1).nullable(),
+  displayName: external_exports.string().min(1).nullable(),
+  avatarUrl: external_exports.string().url().nullable(),
+  automationRoot: AutomationPrincipalSchema.nullable().optional(),
+  totalUsd: ExactUsdSchema,
+  daily: RequesterSpendPeriodSchema,
+  monthly: RequesterSpendPeriodSchema,
+  override: RequesterSpendOverrideStateSchema,
+  capped: external_exports.boolean(),
+  controlVersion: external_exports.number().int().nonnegative().nullable(),
+  manageable: external_exports.boolean(),
+  sources: external_exports.array(RequesterSpendSourceSchema)
+});
+var RequesterSpendListResponseSchema = external_exports.object({
+  asOf: external_exports.string().datetime(),
+  timezone: external_exports.literal("UTC"),
+  canManage: external_exports.boolean(),
+  requesters: external_exports.array(RequesterSpendRowSchema)
+});
+var RequesterSpendUpdateResponseSchema = external_exports.object({
+  requester: RequesterSpendRowSchema
+});
+var REQUESTER_SPEND_ERROR_CODES = [
+  "invalid_request",
+  "requester_not_found",
+  "version_conflict",
+  "unauthorized",
+  "forbidden"
+];
+var RequesterSpendErrorCodeSchema = external_exports.enum(
+  REQUESTER_SPEND_ERROR_CODES
+);
+var RequesterSpendErrorResponseSchema = external_exports.object({
+  error: external_exports.string(),
+  code: RequesterSpendErrorCodeSchema,
+  issues: external_exports.array(external_exports.unknown()).optional(),
+  currentVersion: external_exports.number().int().nonnegative().nullable().optional()
+});
+
+// ../../packages/schemas/src/spend-caps.ts
+var USD_DECIMAL_ERROR = "must be a nonnegative decimal string with at most 10 integer and 10 fractional digits";
+function canonicalUsdDecimal(value) {
+  const [integer2, fraction] = value.split(".");
+  const trimmedFraction = fraction?.replace(/0+$/, "");
+  return trimmedFraction ? `${integer2}.${trimmedFraction}` : integer2 ?? "0";
+}
+var SpendCapUsdSchema = ExactUsdSchema.refine(
+  (value) => (value.split(".")[0]?.length ?? 0) <= 10,
+  USD_DECIMAL_ERROR
+).transform(canonicalUsdDecimal);
+var AgentSpendCapsFields = {
+  dailyUsd: SpendCapUsdSchema.optional(),
+  monthlyUsd: SpendCapUsdSchema.optional(),
+  maxPerSessionUsd: SpendCapUsdSchema.optional()
+};
+var AgentSpendCapsSchema = external_exports.object(AgentSpendCapsFields);
+var AgentSpendCapsAuthoringSchema = external_exports.object(AgentSpendCapsFields).strict();
+var SessionSpendCapSnapshotSchema = external_exports.object({
+  configuredMaxUsd: SpendCapUsdSchema.nullable()
+});
+var AgentSpendCapWindowStatusSchema = external_exports.object({
+  usageUsd: ExactUsdSchema,
+  configuredLimitUsd: SpendCapUsdSchema.nullable(),
+  hit: external_exports.boolean(),
+  resetsAt: external_exports.string().datetime()
+});
+var AgentSpendCapStatusSchema = external_exports.object({
+  daily: AgentSpendCapWindowStatusSchema,
+  monthly: AgentSpendCapWindowStatusSchema
+});
+var SessionSpendCapStatusSchema = external_exports.object({
+  usageUsd: ExactUsdSchema,
+  configuredMaxUsd: SpendCapUsdSchema.nullable(),
+  hit: external_exports.boolean()
+});
+
+// ../../packages/schemas/src/tools.ts
+var REMOTE_MCP_TRANSPORTS = ["streamable_http"];
+var LOCAL_TOOL_IMPLEMENTATIONS = ["auto", "chat", "ping"];
+var BILLING_CAPABILITY_LEVELS = ["none", "read", "write"];
+var BillingCapabilityLevelSchema = external_exports.enum(BILLING_CAPABILITY_LEVELS);
+var PROJECT_MEMBER_CAPABILITY_LEVELS = ["none", "read"];
+var ProjectMemberCapabilityLevelSchema = external_exports.enum(
+  PROJECT_MEMBER_CAPABILITY_LEVELS
+);
+var WAITLIST_REPORTING_CAPABILITY_LEVELS = ["none", "read"];
+var WaitlistReportingCapabilityLevelSchema = external_exports.enum(
+  WAITLIST_REPORTING_CAPABILITY_LEVELS
+);
+var RUNTIME_CAPABILITY_LEVELS = ["none", "read", "write"];
+var RuntimeCapabilityLevelSchema = external_exports.enum(RUNTIME_CAPABILITY_LEVELS);
+var CONNECTION_CAPABILITY_LEVELS = ["none", "read", "write"];
+var ConnectionCapabilityLevelSchema = external_exports.enum(
+  CONNECTION_CAPABILITY_LEVELS
+);
+var SECRET_CAPABILITY_LEVELS = ["none", "read", "write"];
+var SecretCapabilityLevelSchema = external_exports.enum(SECRET_CAPABILITY_LEVELS);
+var WEBHOOK_CAPABILITY_LEVELS = ["none", "write"];
+var WebhookCapabilityLevelSchema = external_exports.enum(WEBHOOK_CAPABILITY_LEVELS);
+function attenuatedCapabilitySchema(input) {
+  return external_exports.union([
+    input.levelSchema,
+    external_exports.object({
+      level: input.levelSchema,
+      unattributed: input.levelSchema
+    }).strict().superRefine((capability, context) => {
+      if (!capabilityLevelAtMost({
+        floor: capability.unattributed,
+        grant: capability.level,
+        levels: input.levels
+      })) {
+        context.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "unattributed capability level must not exceed level",
+          path: ["unattributed"]
+        });
+      }
+    })
+  ]);
+}
+var BillingCapabilitySchema = attenuatedCapabilitySchema({
+  levelSchema: BillingCapabilityLevelSchema,
+  levels: BILLING_CAPABILITY_LEVELS
+});
+var ProjectMemberCapabilitySchema = attenuatedCapabilitySchema({
+  levelSchema: ProjectMemberCapabilityLevelSchema,
+  levels: PROJECT_MEMBER_CAPABILITY_LEVELS
+});
+var WaitlistReportingCapabilitySchema = external_exports.literal("read");
+var RuntimeCapabilitySchema = attenuatedCapabilitySchema({
+  levelSchema: RuntimeCapabilityLevelSchema,
+  levels: RUNTIME_CAPABILITY_LEVELS
+});
+var ConnectionCapabilitySchema = attenuatedCapabilitySchema({
+  levelSchema: ConnectionCapabilityLevelSchema,
+  levels: CONNECTION_CAPABILITY_LEVELS
+});
+var SecretCapabilitySchema = attenuatedCapabilitySchema({
+  levelSchema: SecretCapabilityLevelSchema,
+  levels: SECRET_CAPABILITY_LEVELS
+});
+var WebhookCapabilitySchema = attenuatedCapabilitySchema({
+  levelSchema: WebhookCapabilityLevelSchema,
+  levels: WEBHOOK_CAPABILITY_LEVELS
+});
+var LocalAutoToolCapabilitiesSchema = external_exports.object({
+  billing: BillingCapabilitySchema.default("none"),
+  projectMembers: ProjectMemberCapabilitySchema.default("none"),
+  // Optional preserves legacy persisted tool snapshots byte-for-byte while
+  // making absence an explicit deny at every read site.
+  waitlistReporting: WaitlistReportingCapabilitySchema.optional(),
+  runtimes: RuntimeCapabilitySchema.default("none"),
+  connections: ConnectionCapabilitySchema.optional(),
+  secrets: SecretCapabilitySchema.optional(),
+  webhooks: WebhookCapabilitySchema.optional()
+}).strict().default({
+  billing: "none",
+  projectMembers: "none",
+  runtimes: "none"
+});
+var SecretReferenceSchema = external_exports.object({
+  $secret: ResourceNameSchema
+});
+var NoToolAuthSchema = external_exports.object({
+  kind: external_exports.literal("none")
+});
+var OptionalConnectionField = {
+  optional: external_exports.boolean().optional()
+};
+var McpOAuthToolAuthSchema = external_exports.object({
+  kind: external_exports.literal("mcp_oauth"),
+  connection: ResourceNameSchema,
+  ...OptionalConnectionField
+});
+var ConnectionToolAuthSchema = ProviderConnectionReferenceSchema.extend({
+  kind: external_exports.literal("connection"),
+  ...OptionalConnectionField
+});
+var ConnectionsToolAuthSchema = external_exports.object({
+  kind: external_exports.literal("connections"),
+  connections: external_exports.array(ProviderConnectionReferenceSchema).min(1),
+  ...OptionalConnectionField
+});
+var ConnectionMcpToolNameSchema = external_exports.string().trim().min(1, "Connection-backed MCP tool names must not be empty");
+var ConnectionMcpToolAllowlistSchema = external_exports.array(ConnectionMcpToolNameSchema).min(1, "Connection-backed MCP tool allowlists must name at least one tool").superRefine((tools, context) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, tool] of tools.entries()) {
+    if (seen.has(tool)) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        message: "Connection-backed MCP tool names must be unique after trimming",
+        path: [index]
+      });
+    }
+    seen.add(tool);
+  }
+});
+var ConnectionBackedToolSchema = ProviderConnectionReferenceSchema.extend({
+  kind: external_exports.literal("connection"),
+  description: external_exports.string().trim().min(1).optional(),
+  tools: ConnectionMcpToolAllowlistSchema.optional(),
+  ...OptionalConnectionField
+});
+var ToolAliasSchema = ResourceNameSchema.refine(
+  (value) => value !== "workspace",
+  {
+    message: 'Tool alias "workspace" is reserved by Claude Code'
+  }
+);
+function remoteMcpUrlSchema(input) {
+  return external_exports.string().trim().url().refine(
+    (value) => {
+      const url2 = new URL(value);
+      if (url2.protocol === "https:") {
+        return true;
+      }
+      if (!input?.allowInsecureLocal || url2.protocol !== "http:") {
+        return false;
+      }
+      return url2.hostname === "localhost" || url2.hostname === "127.0.0.1";
+    },
+    {
+      message: "Remote MCP URLs must use https; http is only allowed for explicit local development parsing"
+    }
+  );
+}
+function remoteMcpToolSchema(input) {
+  return external_exports.object({
+    kind: external_exports.literal("mcp_remote"),
+    description: external_exports.string().trim().min(1).optional(),
+    url: remoteMcpUrlSchema(input),
+    transport: external_exports.enum(REMOTE_MCP_TRANSPORTS).default("streamable_http"),
+    auth: external_exports.discriminatedUnion("kind", [
+      NoToolAuthSchema,
+      external_exports.object({
+        kind: external_exports.literal("bearer"),
+        token: SecretReferenceSchema
+      }),
+      McpOAuthToolAuthSchema,
+      ProviderConnectionReferenceSchema.extend({
+        kind: external_exports.literal("provider_oauth"),
+        ...OptionalConnectionField
+      })
+    ]).default({ kind: "none" })
+  });
+}
+var RemoteMcpToolSchema = remoteMcpToolSchema();
+var LocalAutoToolSchema = external_exports.object({
+  kind: external_exports.literal("local"),
+  implementation: external_exports.literal("auto"),
+  description: external_exports.string().trim().min(1).optional(),
+  capabilities: LocalAutoToolCapabilitiesSchema,
+  auth: NoToolAuthSchema.default({ kind: "none" })
+});
+var LocalPingToolSchema = external_exports.object({
+  kind: external_exports.literal("local"),
+  implementation: external_exports.literal("ping"),
+  description: external_exports.string().trim().min(1).optional(),
+  auth: NoToolAuthSchema.default({ kind: "none" })
+});
+var LocalChatToolSchema = external_exports.object({
+  kind: external_exports.literal("local"),
+  implementation: external_exports.literal("chat"),
+  description: external_exports.string().trim().min(1).optional(),
+  auth: external_exports.discriminatedUnion("kind", [
+    ConnectionToolAuthSchema,
+    ConnectionsToolAuthSchema
+  ])
+});
+var LocalToolSchema = external_exports.discriminatedUnion(
+  "implementation",
+  [LocalAutoToolSchema, LocalChatToolSchema, LocalPingToolSchema],
+  {
+    error: `Unsupported local tool implementation. Supported implementations: ${LOCAL_TOOL_IMPLEMENTATIONS.join(", ")}`
+  }
+);
+var PersistedLocalToolSchema = external_exports.preprocess(
+  normalizePersistedTaskEraLocalAutoTool,
+  LocalToolSchema
+);
+function normalizePersistedTaskEraLocalAutoTool(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value;
+  }
+  const tool = value;
+  if (tool.kind !== "local" || tool.implementation !== "auto" || typeof tool.capabilities !== "object" || tool.capabilities === null || Array.isArray(tool.capabilities)) {
+    return value;
+  }
+  const {
+    tasks: _tasks,
+    taskManagement: _taskManagement,
+    ...capabilities
+  } = tool.capabilities;
+  return { ...tool, capabilities };
+}
+var GithubToolSchema = external_exports.object({
+  kind: external_exports.literal("github"),
+  description: external_exports.string().trim().min(1).optional(),
+  tools: external_exports.array(external_exports.enum(GITHUB_MCP_SELECTABLE_TOOL_NAMES)).min(1).optional()
+});
+var ToolSpecSchema = external_exports.discriminatedUnion("kind", [
+  RemoteMcpToolSchema,
+  ConnectionBackedToolSchema,
+  LocalToolSchema
+]);
+var AgentToolConnectRequestSchema = external_exports.object({
+  redirectUri: external_exports.string().trim().url().refine(
+    (value) => {
+      const url2 = new URL(value);
+      if (url2.protocol === "https:") {
+        return true;
+      }
+      return url2.protocol === "http:" && (url2.hostname === "localhost" || url2.hostname === "127.0.0.1");
+    },
+    {
+      message: "Agent tool OAuth redirect URIs must use https, except localhost loopback callbacks may use http"
+    }
+  ).optional()
+});
+var AgentToolConnectResponseSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({
+    status: external_exports.literal("authorization_required"),
+    agent: ResourceNameSchema.optional(),
+    tool: ResourceNameSchema,
+    connection: ResourceNameSchema,
+    authorizationUrl: external_exports.string().trim().url(),
+    message: external_exports.string().trim().min(1)
+  }),
+  external_exports.object({
+    status: external_exports.literal("connected"),
+    agent: ResourceNameSchema.optional(),
+    tool: ResourceNameSchema,
+    connection: ResourceNameSchema,
+    message: external_exports.string().trim().min(1)
+  })
+]);
+var AgentToolConnectCompleteResponseSchema = external_exports.object({
+  status: external_exports.literal("connected"),
+  agent: ResourceNameSchema.optional(),
+  tool: ResourceNameSchema,
+  connection: ResourceNameSchema,
+  projectId: ProjectIdSchema
+});
+var InlineAgentToolSchema = RemoteMcpToolSchema.extend({
+  disabled: external_exports.boolean().optional()
+}).or(
+  ConnectionBackedToolSchema.extend({
+    disabled: external_exports.boolean().optional()
+  })
+).or(
+  LocalToolSchema.and(
+    external_exports.object({
+      disabled: external_exports.boolean().optional()
+    })
+  )
+).or(
+  GithubToolSchema.extend({
+    disabled: external_exports.boolean().optional()
+  })
+);
+var AgentToolRefSchema = InlineAgentToolSchema;
+var AgentToolsSchema = external_exports.record(ToolAliasSchema, AgentToolRefSchema);
+
+// ../../packages/schemas/src/trigger-filters.ts
+var TriggerFilterScalarSchema = external_exports.union([
+  external_exports.null(),
+  external_exports.string(),
+  external_exports.number(),
+  external_exports.boolean()
+]);
+var TriggerFilterPathSchema = external_exports.string().refine(
+  (path2) => {
+    if (path2.length === 0 || path2.trim() !== path2) {
+      return false;
+    }
+    if (path2.startsWith("$.")) {
+      const segments = path2.slice(2).split(".");
+      return segments.length > 0 && segments.every(
+        (segment) => segment.length > 0 && segment.trim() === segment
+      );
+    }
+    return !path2.includes(".");
+  },
+  {
+    message: "Trigger filter paths must be a single bare key or use $.path.segments"
+  }
+);
+var TriggerFilterClauseSchema = external_exports.union([
+  TriggerFilterScalarSchema,
+  external_exports.object({ contains: TriggerFilterScalarSchema }).strict(),
+  external_exports.object({ exists: external_exports.boolean() }).strict(),
+  external_exports.object({ in: external_exports.array(TriggerFilterScalarSchema).min(1) }).strict(),
+  external_exports.object({ notIn: external_exports.array(TriggerFilterScalarSchema).min(1) }).strict(),
+  external_exports.object({ changedTo: TriggerFilterScalarSchema }).strict()
+]);
+var TriggerFilterRecordSchema = external_exports.record(
+  TriggerFilterPathSchema,
+  TriggerFilterClauseSchema
+);
+var TriggerFilterSchema = TriggerFilterRecordSchema.default({});
+
+// ../../packages/schemas/src/trigger-router.ts
+var TRIGGER_ON_UNMATCHED_POLICIES = [
+  "drop",
+  "warn",
+  "error",
+  "spawn"
+];
+var OnUnmatchedSchema = external_exports.enum(TRIGGER_ON_UNMATCHED_POLICIES);
+var RouteSchema = external_exports.union([
+  external_exports.object({ to: external_exports.literal("new") }).strict(),
+  external_exports.object({
+    to: external_exports.literal("slot"),
+    onUnmatched: OnUnmatchedSchema
+  }).strict(),
+  external_exports.object({ to: external_exports.literal("all") }).strict(),
+  external_exports.object({
+    to: external_exports.object({ target: BindingTargetTypeSchema }).strict(),
+    onUnmatched: OnUnmatchedSchema
+  }).strict()
+]);
+var TriggerEffectTargetSchema = external_exports.object({ target: BindingTargetTypeSchema }).strict();
+var TriggerEffectsSchema = external_exports.object({
+  bind: TriggerEffectTargetSchema.optional(),
+  release: TriggerEffectTargetSchema.optional(),
+  complete: external_exports.literal(true).optional()
+}).strict();
+var TriggerGuardSchema = external_exports.object({ managedCheckSuccess: ResourceNameSchema }).strict();
+var SourceEventRequestSchema = external_exports.object({
+  organizationId: external_exports.string().trim().min(1),
+  projectId: external_exports.string().trim().min(1).nullable().optional(),
+  providerGrantId: external_exports.string().trim().min(1).nullable().optional(),
+  webhookEndpointId: external_exports.string().trim().min(1).nullable().optional(),
+  /** Address the event to one agent; only its triggers may match. */
+  targetAgentResourceId: external_exports.string().trim().min(1).nullable().optional(),
+  event: external_exports.string().trim().min(1),
+  payload: JsonValueSchema2.default({}),
+  dedupKey: external_exports.string().trim().min(1),
+  occurredAt: external_exports.string().datetime().optional()
+});
+var EventRoutingWorkflowInputSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    kind: external_exports.literal("trigger"),
+    eventRecordId: external_exports.string().uuid()
+  }).strict(),
+  external_exports.object({
+    kind: external_exports.literal("command"),
+    commandId: SessionCommandIdSchema2
+  }).strict()
+]);
+var HeartbeatTickWorkflowInputSchema = external_exports.preprocess(
+  normalizeLegacyHeartbeatTickWorkflowInput,
+  external_exports.object({
+    scheduleId: external_exports.string().trim().min(1),
+    organizationId: external_exports.string().trim().min(1),
+    projectId: external_exports.string().trim().min(1).nullable(),
+    agentResourceId: external_exports.string().trim().min(1),
+    agentName: external_exports.string().trim().min(1).max(256).nullable().default(null),
+    triggerId: external_exports.string().trim().min(1).max(512).nullable().default(null),
+    triggerOrdinal: external_exports.number().int().nonnegative(),
+    cron: external_exports.string().trim().min(1).max(512).nullable().default(null),
+    timezone: external_exports.string().trim().min(1).max(128).nullable().default(null),
+    event: external_exports.string().trim().min(1)
+  }).strict()
+);
+var GithubPullRequestMergeabilityWorkflowInputSchema = external_exports.object({
+  organizationId: external_exports.string().trim().min(1),
+  providerGrantId: external_exports.string().trim().min(1),
+  source: external_exports.string().trim().min(1),
+  eventPayload: JsonValueSchema2,
+  artifactExternalId: external_exports.string().trim().min(1),
+  installationId: external_exports.string().trim().min(1),
+  repoFullName: external_exports.string().trim().min(1),
+  pullRequestNumber: external_exports.number().int().positive(),
+  headSha: external_exports.string().trim().min(1),
+  headRef: external_exports.string().trim().min(1).optional(),
+  baseSha: external_exports.string().trim().min(1).optional(),
+  ciWatchdogWorkflows: external_exports.array(GithubSyncCiWatchdogWorkflowSchema).max(10).default([]),
+  retryDelaysMs: external_exports.array(external_exports.number().int().nonnegative()).default([1e3, 2e3, 5e3, 1e4, 15e3]),
+  ciWorkflowRunCheckDelayMs: external_exports.number().int().nonnegative().default(GITHUB_SYNC_CI_WATCHDOG_DEFAULT_DELAY_MS)
+}).strict();
+var GithubPullRequestMergeabilityWorkflowResultSchema = external_exports.union([
+  external_exports.object({
+    kind: external_exports.literal("conflict"),
+    eventRecordId: external_exports.string().uuid(),
+    created: external_exports.boolean(),
+    dispatch: external_exports.literal("started"),
+    workflowId: external_exports.string().min(1)
+  }),
+  external_exports.object({
+    kind: external_exports.literal("not_conflict"),
+    mergeable: external_exports.boolean().nullable(),
+    mergeableState: external_exports.string().optional(),
+    // Present when the pull request was behind its base with auto-merge
+    // enabled: "updated" if a branch update was requested, "skipped" if
+    // GitHub rejected it (e.g. the head moved since lookup).
+    branchUpdate: external_exports.enum(["updated", "skipped"]).optional(),
+    ciWorkflowDispatch: external_exports.enum(["dispatched", "present", "skipped"]).optional()
+  })
+]);
+var EventRoutingTriggerResultSchema = external_exports.object({
+  eventRecordId: external_exports.string().uuid(),
+  matchedTriggers: external_exports.number().int().nonnegative(),
+  deliveries: external_exports.number().int().nonnegative()
+});
+function normalizeLegacyHeartbeatTickWorkflowInput(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return input;
+  }
+  if ("agentResourceId" in input || !("sessionResourceId" in input)) {
+    return input;
+  }
+  const { sessionResourceId, ...rest } = input;
+  return {
+    ...rest,
+    agentResourceId: sessionResourceId
+  };
+}
+
+// ../../packages/schemas/src/agents.ts
+var RESOURCE_KIND_AGENT = "agent";
+var AGENT_HARNESSES = ["claude-code", "codex"];
+var AgentHarnessSchema = external_exports.enum(AGENT_HARNESSES);
+var TriggerCheckTimeoutSchema = external_exports.object({
+  seconds: external_exports.number().int().min(1).max(7 * 24 * 60 * 60),
+  conclusion: external_exports.enum(["success", "failure", "skipped"])
+}).strict();
+var AgentArchiveAfterInactiveSchema = external_exports.object({
+  seconds: external_exports.number().int().min(60).max(365 * 24 * 60 * 60)
+}).strict();
+var AgentSessionPolicySchema = external_exports.object({
+  archiveAfterInactive: AgentArchiveAfterInactiveSchema.optional()
+}).strict().default({});
+var AgentConcurrencySchema = external_exports.number().int().refine((value) => value === 1, {
+  message: "Only `concurrency: 1` is supported; larger pools are a deliberate non-goal for now (see docs/agent-concurrency.md)"
+});
+var AgentReplacePolicySchema = external_exports.literal("auto");
+var AgentManagesSchema = external_exports.array(ResourceNameSchema).max(64);
+var AgentConnectionsSchema = external_exports.union([
+  external_exports.literal("all"),
+  external_exports.literal("none"),
+  external_exports.array(ConnectionNameSchema),
+  external_exports.object({
+    exclude: external_exports.array(ConnectionNameSchema)
+  }).strict()
+]);
+var TriggerEventSchema = external_exports.string().trim().min(1);
+var TriggerEventsSchema = external_exports.array(TriggerEventSchema).min(1).superRefine((events, context) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, event] of events.entries()) {
+    if (seen.has(event)) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: [index],
+        message: "Trigger events must be unique"
+      });
+    }
+    seen.add(event);
+  }
+});
+var PAYLOAD_PREFIXED_TEMPLATE_TOKEN = /\{\{\s*(payload(?:\.[A-Za-z0-9_.-]+)?)\s*\}\}/g;
+function refineNoPayloadPrefixedTemplateTokens(value, context) {
+  if (value === void 0) {
+    return;
+  }
+  const offending = new Set(
+    [...value.matchAll(PAYLOAD_PREFIXED_TEMPLATE_TOKEN)].map(
+      (match) => match[0]
+    )
+  );
+  if (offending.size > 0) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      message: `Template renders against the event payload; drop the "payload." prefix (use "{{github.\u2026}}", not "{{payload.github.\u2026}}"). Offending tokens: ${[...offending].join(", ")}`
+    });
+  }
+}
+function templateField(guard) {
+  const field = external_exports.string().trim().min(1).max(2e4).optional();
+  return guard === "authoring" ? field.superRefine(refineNoPayloadPrefixedTemplateTokens) : field;
+}
+function attachedUserPromptField() {
+  return external_exports.string().min(1).max(2e4).refine((value) => value.trim().length > 0, {
+    message: "Attached user prompt must contain non-whitespace text"
+  }).optional();
+}
+function displayTitleField(guard) {
+  const field = external_exports.union([
+    external_exports.literal("infer"),
+    external_exports.string().trim().min(1).max(2e4)
+  ]);
+  return (guard === "authoring" ? field.superRefine((value, context) => {
+    if (value !== "infer") {
+      refineNoPayloadPrefixedTemplateTokens(value, context);
+    }
+  }) : field).optional();
+}
+var TriggerChecksField = external_exports.array(
+  external_exports.object({
+    name: ResourceNameSchema,
+    displayName: external_exports.string().trim().min(1).max(256),
+    description: external_exports.string().trim().min(1).max(65535),
+    instructions: external_exports.string().trim().min(1).max(2e4).optional(),
+    timeout: TriggerCheckTimeoutSchema.optional(),
+    beginTimeout: TriggerCheckTimeoutSchema.optional(),
+    completeTimeout: TriggerCheckTimeoutSchema.optional()
+  }).strict().superRefine((check2, context) => {
+    if (check2.timeout && check2.beginTimeout) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["beginTimeout"],
+        message: "Use either timeout or beginTimeout for the creation-to-begin timeout, not both"
+      });
+    }
+  })
+).optional();
+function triggerSharedFields(guard) {
+  return {
+    message: templateField(guard),
+    attachedUserPrompt: attachedUserPromptField(),
+    checks: TriggerChecksField,
+    // Catch-all flag: a `fallback` trigger fires only when no normal (non-
+    // fallback) trigger on the same endpoint + eventKey matched its `where`.
+    // It is the one cross-trigger negation the per-payload matcher cannot
+    // express, so it must be an explicit flag rather than overloaded empty
+    // `where` (which already means match-all). See the trigger-router partition
+    // in packages/db/src/trigger-router/triggers.ts.
+    fallback: external_exports.boolean().default(false),
+    route: RouteSchema,
+    effects: TriggerEffectsSchema.optional(),
+    guard: TriggerGuardSchema.optional()
+  };
+}
+var TriggerEventSourceFields = {
+  connection: ConnectionNameSchema.optional(),
+  // Mark a connection-bound trigger optional so apply silently skips it (rather
+  // than failing) when the referenced connection has no active grant. The
+  // skipped trigger is omitted from the applied agent and re-activates on the
+  // next apply/sync once the connection is set up.
+  optional: external_exports.boolean().optional(),
+  endpoint: external_exports.string().trim().min(1).optional(),
+  auth: external_exports.discriminatedUnion("kind", [
+    external_exports.object({
+      kind: external_exports.literal("hmac_sha256"),
+      secretRef: external_exports.string().trim().min(1)
+    }),
+    external_exports.object({
+      kind: external_exports.literal("bearer_token"),
+      secretRef: external_exports.string().trim().min(1)
+    }),
+    external_exports.object({
+      kind: external_exports.literal("none")
+    })
+  ]).optional()
+};
+function triggerBaseSchema(guard) {
+  return external_exports.object({
+    event: TriggerEventSchema,
+    ...triggerSharedFields(guard),
+    ...TriggerEventSourceFields
+  }).strict().superRefine((trigger, context) => {
+    validateTriggerChecks(trigger, context, [trigger.event]);
+    validateAttachedUserPrompt(trigger, context, guard);
+  });
+}
+function triggerDefinitionBaseSchema(guard) {
+  return external_exports.object({
+    event: TriggerEventSchema.optional(),
+    events: TriggerEventsSchema.optional(),
+    ...triggerSharedFields(guard),
+    ...TriggerEventSourceFields
+  }).strict().superRefine((trigger, context) => {
+    if (trigger.event && trigger.events) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["events"],
+        message: "Use either event or events, not both"
+      });
+    }
+    if (!trigger.event && !trigger.events) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["event"],
+        message: "Trigger requires event or events"
+      });
+    }
+    validateTriggerChecks(
+      trigger,
+      context,
+      trigger.event ? [trigger.event] : trigger.events ?? []
+    );
+    validateAttachedUserPrompt(trigger, context, guard);
+  });
+}
+function heartbeatTriggerBaseSchema(guard) {
+  return external_exports.object({
+    kind: external_exports.literal("heartbeat"),
+    event: external_exports.never().optional(),
+    connection: external_exports.never().optional(),
+    optional: external_exports.never().optional(),
+    endpoint: external_exports.never().optional(),
+    auth: external_exports.never().optional(),
+    cron: external_exports.string().trim().min(1).max(512),
+    timezone: external_exports.string().trim().min(1).max(128).default("UTC"),
+    ...triggerSharedFields(guard)
+  }).strict().superRefine((trigger, context) => {
+    validateTriggerChecks(trigger, context, ["heartbeat"]);
+    validateAttachedUserPrompt(trigger, context, guard);
+  });
+}
+var TriggerSchema = triggerBaseSchema("stored").extend({
+  where: external_exports.record(external_exports.string(), JsonValueSchema2).default({})
+});
+var ApplyTriggerSchema = triggerBaseSchema("authoring").extend({
+  where: TriggerFilterSchema
+});
+var HeartbeatTriggerSchema = heartbeatTriggerBaseSchema(
+  "stored"
+).extend({
+  where: external_exports.record(external_exports.string(), JsonValueSchema2).default({})
+});
+var ApplyHeartbeatTriggerSchema = heartbeatTriggerBaseSchema(
+  "authoring"
+).extend({
+  where: TriggerFilterSchema
+});
+var TriggerDefinitionSchema = triggerDefinitionBaseSchema("stored").extend({
+  where: external_exports.record(external_exports.string(), JsonValueSchema2).default({})
+});
+var ApplyTriggerDefinitionSchema = triggerDefinitionBaseSchema(
+  "authoring"
+).extend({
+  where: TriggerFilterSchema
+});
+var TriggersSchema = external_exports.array(external_exports.union([TriggerDefinitionSchema, HeartbeatTriggerSchema])).transform(expandTriggerDefinitions).superRefine(validateAttributedRunsTriggerPairing);
+var ApplyTriggersSchema = external_exports.array(external_exports.union([ApplyTriggerDefinitionSchema, ApplyHeartbeatTriggerSchema])).transform(expandApplyTriggerDefinitions).superRefine(validateAttributedRunsTriggerPairing);
+var AVATAR_ASSET_EXTENSIONS = [".png", ".jpg", ".jpeg"];
+var MAX_AVATAR_ASSET_BYTES = 2 * 1024 * 1024;
+var AGENT_IDENTITY_DESCRIPTION_MAX_LENGTH = 140;
+function agentIdentityDescriptionLength(value) {
+  let length = 0;
+  for (const char of value) {
+    const codePoint = char.codePointAt(0) ?? 0;
+    if (codePoint < 32 || codePoint > 126) {
+      length += 6 * char.length;
+    } else if (char === '"' || char === "\\" || char === "/") {
+      length += 2;
+    } else {
+      length += 1;
+    }
+  }
+  return length;
+}
+function clampAgentIdentityDescription(value) {
+  if (agentIdentityDescriptionLength(value) <= AGENT_IDENTITY_DESCRIPTION_MAX_LENGTH) {
+    return value;
+  }
+  let clamped = "";
+  let length = 0;
+  for (const char of value) {
+    const charLength = agentIdentityDescriptionLength(char);
+    if (length + charLength > AGENT_IDENTITY_DESCRIPTION_MAX_LENGTH) break;
+    clamped += char;
+    length += charLength;
+  }
+  return clamped.trimEnd();
+}
+var SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/;
+function isAvatarAssetPathShapeValid(asset) {
+  const normalized = asset.trim().replaceAll("\\", "/");
+  if (normalized.length === 0) return false;
+  if (normalized.startsWith("/")) return false;
+  if (/^[A-Za-z]:\//.test(normalized)) return false;
+  if (normalized.split("/").includes("..")) return false;
+  if (!normalized.startsWith(".auto/assets/")) return false;
+  const lower = normalized.toLowerCase();
+  return AVATAR_ASSET_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+var AgentIdentitySchema = external_exports.object({
+  displayName: external_exports.string().trim().min(1).max(80).optional(),
+  username: external_exports.string().trim().min(1).max(80).optional(),
+  avatar: external_exports.object({
+    asset: external_exports.string().trim().min(1).max(1024).refine(isAvatarAssetPathShapeValid, {
+      message: "avatar.asset must be a relative path under .auto/assets with a .png, .jpg, or .jpeg extension"
+    }),
+    // Content hash of the stored asset bytes. When the apply carries the
+    // asset's bytes, the server re-derives and overwrites this value. When
+    // it does not, a declared hash resolves only an already-stored or
+    // built-in catalog avatar (managed templates bake references this
+    // way); it can never attach arbitrary bytes.
+    sha256: external_exports.string().regex(SHA256_HEX_PATTERN).optional()
+  }).strict().optional(),
+  description: external_exports.string().trim().min(1).refine(
+    (value) => agentIdentityDescriptionLength(value) <= AGENT_IDENTITY_DESCRIPTION_MAX_LENGTH,
+    {
+      message: `description must be at most ${AGENT_IDENTITY_DESCRIPTION_MAX_LENGTH} characters as Slack counts them (a non-ASCII character like "\u2014" counts as 6)`
+    }
+  ).optional()
+}).strict().refine((identity) => Object.keys(identity).length > 0, {
+  message: "Identity requires at least one field"
+});
+var PersistedAgentIdentitySchema = external_exports.preprocess(
+  normalizePersistedAgentIdentity,
+  AgentIdentitySchema.optional()
+);
+function normalizePersistedAgentIdentity(value) {
+  if (typeof value !== "object" || value === null) return value;
+  const identity = value;
+  if (typeof identity.description !== "string") return value;
+  if (agentIdentityDescriptionLength(identity.description) <= AGENT_IDENTITY_DESCRIPTION_MAX_LENGTH) {
+    return value;
+  }
+  const clamped = clampAgentIdentityDescription(identity.description);
+  const normalizedIdentity = { ...identity };
+  if (clamped.length > 0) normalizedIdentity.description = clamped;
+  else delete normalizedIdentity.description;
+  return Object.keys(normalizedIdentity).length > 0 ? normalizedIdentity : void 0;
+}
+var BindingLifecycleSpecSchema = external_exports.object({
+  lifecycle: external_exports.enum(["session", "agent"]).default("session"),
+  bindOn: external_exports.array(BindingActionSchema).optional()
+}).strict();
+var AgentBindingsSchema = external_exports.record(external_exports.string(), BindingLifecycleSpecSchema).superRefine((bindings, context) => {
+  for (const key of Object.keys(bindings)) {
+    const parsed = BindingTargetTypeSchema.safeParse(key);
+    if (!parsed.success) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: [key],
+        message: `\`${key}\` is not a valid binding target type`
+      });
+    }
+  }
+});
+var AgentSpecFieldsSchema = external_exports.object({
+  harness: external_exports.enum(AGENT_HARNESSES).optional(),
+  model: AgentModelSelectionSchema.optional(),
+  reasoningEffort: AgentReasoningEffortSchema.optional(),
+  systemPrompt: external_exports.string().trim().min(1).max(1e5).optional(),
+  environment: ResourceNameSchema.optional(),
+  identity: external_exports.union([ResourceNameSchema, AgentIdentitySchema]).optional(),
+  initialPrompt: templateField("stored"),
+  displayTitle: displayTitleField("stored"),
+  env: SecretEnvSchema.default({}),
+  mounts: external_exports.array(AgentMountSchema).default([]),
+  triggers: TriggersSchema.default([]),
+  session: AgentSessionPolicySchema,
+  spendCaps: AgentSpendCapsSchema.optional(),
+  concurrency: AgentConcurrencySchema.optional(),
+  replace: AgentReplacePolicySchema.optional(),
+  onReplace: external_exports.string().trim().min(1).max(2e4).optional(),
+  manages: AgentManagesSchema.optional(),
+  bindings: AgentBindingsSchema.default({}),
+  workingDirectory: external_exports.string().trim().min(1).optional(),
+  connections: AgentConnectionsSchema.optional(),
+  tools: AgentToolsSchema.default({})
+});
+function validateRunnableConfig(spec, context) {
+  if (!spec.harness) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["harness"],
+      message: "Agent requires harness"
+    });
+  }
+  if (!spec.environment) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["environment"],
+      message: "Agent requires environment"
+    });
+  }
+}
+var AgentSpecSchema = AgentSpecFieldsSchema.superRefine(
+  (spec, context) => {
+    validateRunnableConfig(spec, context);
+    validateAgentModelFieldsForHarness(spec, context);
+  }
+);
+var AgentApplySpecFieldsSchema = AgentSpecFieldsSchema.extend({
+  initialPrompt: templateField("authoring"),
+  displayTitle: displayTitleField("authoring"),
+  triggers: ApplyTriggersSchema.default([]),
+  spendCaps: AgentSpendCapsAuthoringSchema.optional()
+});
+var AgentApplySpecSchema = AgentApplySpecFieldsSchema.superRefine(
+  (spec, context) => {
+    validateRunnableConfig(spec, context);
+    validateAgentModelFieldsForHarness(spec, context);
+    validateConcurrencyConfig(spec, context);
+    validateBindingsConfig(spec, context);
+    validateTriggerGuardConfig(spec, context);
+    validateTriggerEffectsConfig(spec, context);
+  }
+);
+function validateTriggerEffectsConfig(spec, context) {
+  for (const [index, trigger] of spec.triggers.entries()) {
+    if (!trigger.effects?.bind || typeof trigger.route.to !== "object" || trigger.route.onUnmatched !== "spawn" || trigger.effects.bind.target !== trigger.route.to.target) {
+      continue;
+    }
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["triggers", index, "effects", "bind"],
+      message: "`effects.bind` cannot duplicate a target route with `onUnmatched: spawn`; that route claims its target atomically during session creation"
+    });
+  }
+}
+function validateTriggerGuardConfig(spec, context) {
+  const managedCheckNames = new Set(
+    spec.triggers.flatMap(
+      (trigger) => (trigger.checks ?? []).map((check2) => check2.name)
+    )
+  );
+  for (const [index, trigger] of spec.triggers.entries()) {
+    if (!trigger.guard) {
+      continue;
+    }
+    if (typeof trigger.route.to !== "object" || trigger.route.to.target !== "github.pull_request") {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["triggers", index, "guard", "managedCheckSuccess"],
+        message: "`guard.managedCheckSuccess` requires `route.to.target: github.pull_request`: managed check cycles and authoritative head state are pull-request scoped"
+      });
+    }
+    if (!managedCheckNames.has(trigger.guard.managedCheckSuccess)) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["triggers", index, "guard", "managedCheckSuccess"],
+        message: "`guard.managedCheckSuccess` must name a managed check declared in this agent's `triggers[].checks`"
+      });
+    }
+  }
+}
+function validateConcurrencyConfig(spec, context) {
+  if (spec.concurrency === void 0 && spec.replace !== void 0) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["replace"],
+      message: "`replace` requires `concurrency` (the cap it manages)"
+    });
+  }
+  if (spec.onReplace !== void 0 && spec.replace === void 0) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["onReplace"],
+      message: "`onReplace` requires `replace: auto` (it is the rebuild prompt delivered to platform-spawned replacements; nothing consumes it otherwise)"
+    });
+  }
+  if (spec.concurrency !== void 0) {
+    return;
+  }
+  const hasSlotClaimingSpawn = spec.triggers.some(
+    (trigger) => isSlotRoute(trigger) && trigger.route.onUnmatched === "spawn"
+  );
+  if (hasSlotClaimingSpawn) {
+    return;
+  }
+  for (const [index, trigger] of spec.triggers.entries()) {
+    if (isSlotRoute(trigger)) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["triggers", index, "route", "to"],
+        message: "A `route.to: slot` trigger resolves the agent's concurrency slot; set `concurrency: 1` on the agent or use `onUnmatched: spawn`"
+      });
+    }
+  }
+}
+function isSlotRoute(trigger) {
+  return trigger.route.to === "slot";
+}
+function validateBindingActions(bindings, context) {
+  for (const [target, config2] of Object.entries(bindings)) {
+    const parsed = BindingTargetTypeSchema.safeParse(target);
+    const targetType = parsed.success ? parsed.data : null;
+    const actions = config2.bindOn ?? [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const [index, action] of actions.entries()) {
+      if (seen.has(action)) {
+        context.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          path: ["bindings", target, "bindOn", index],
+          message: "Binding actions must be unique"
+        });
+      }
+      seen.add(action);
+      const legal = BINDING_ACTION_LEGAL_TARGETS[action];
+      if (targetType && legal.has(targetType)) {
+        continue;
+      }
+      const legalList = [...legal].join(", ");
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["bindings", target, "bindOn", index],
+        message: `\`bindOn: ${action}\` is legal only for [${legalList}]; "${target}" is not a valid target for this binding action`
+      });
+    }
+  }
+}
+function validateBindingsConfig(spec, context) {
+  if (spec.bindings) validateBindingActions(spec.bindings, context);
+}
+var AgentStatusSchema = external_exports.object({
+  runCount: external_exports.number().int().nonnegative().default(0),
+  lastActivityAt: external_exports.string().datetime().nullable().default(null)
+}).default({ runCount: 0, lastActivityAt: null });
+var AgentResourceOriginSchema = external_exports.enum(["authored", "built_in"]);
+var AgentResourceSchema = resourceEnvelopeSchema(
+  AgentSpecSchema
+).extend({
+  status: AgentStatusSchema,
+  origin: AgentResourceOriginSchema.optional()
+});
+var PersistedAgentResourceSchema = external_exports.preprocess(
+  normalizePersistedAgentResource,
+  AgentResourceSchema
+);
+function normalizePersistedAgentResource(value) {
+  if (typeof value !== "object" || value === null) return value;
+  const resource = value;
+  if (!resource.spec) return value;
+  const normalizedSpec = normalizePersistedAgentSpec(resource.spec);
+  const normalizedIdentity = normalizePersistedAgentIdentity(
+    normalizedSpec.identity
+  );
+  return {
+    ...resource,
+    spec: {
+      ...normalizedSpec,
+      identity: normalizedIdentity
+    }
+  };
+}
+function normalizePersistedAgentSpec(spec) {
+  const normalized = normalizePersistedAgentGrammar(spec);
+  const bindings = normalizePersistedTaskEraBindings(normalized.bindings);
+  const tools = normalizePersistedTaskEraTools(normalized.tools);
+  return { ...normalized, bindings, tools };
+}
+function normalizePersistedTaskEraBindings(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value;
+  }
+  const { "auto.task": _retiredTaskBinding, ...bindings } = value;
+  return bindings;
+}
+function normalizePersistedTaskEraTools(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([name, tool]) => {
+      if (typeof tool !== "object" || tool === null || Array.isArray(tool)) {
+        return [name, tool];
+      }
+      const candidate = tool;
+      if (candidate.kind !== "local" || candidate.implementation !== "auto" || typeof candidate.capabilities !== "object" || candidate.capabilities === null || Array.isArray(candidate.capabilities)) {
+        return [name, tool];
+      }
+      const {
+        tasks: _tasks,
+        taskManagement: _taskManagement,
+        ...capabilities
+      } = candidate.capabilities;
+      return [name, { ...candidate, capabilities }];
+    })
+  );
+}
+var AgentApplyRequestSchema = resourceApplySchema(AgentApplySpecSchema);
+var ApplyTriggerReceiptSchema = external_exports.object({
+  event: external_exports.string().trim().min(1),
+  endpoint: external_exports.string().trim().min(1),
+  ingestUrl: external_exports.string().trim().min(1),
+  status: external_exports.literal("ready")
+});
+var AgentApplyResponseSchema = external_exports.union([
+  AgentResourceSchema,
+  external_exports.object({
+    resource: AgentResourceSchema,
+    triggers: external_exports.array(ApplyTriggerReceiptSchema)
+  })
+]);
+var AGENT_TELEGRAM_IDENTITY_STATUSES = [
+  "pending",
+  "realized",
+  "broken",
+  "retired"
+];
+var AgentTelegramIdentityStatusSchema = external_exports.enum(
+  AGENT_TELEGRAM_IDENTITY_STATUSES
+);
+var AgentPresenceIdentitySchema = external_exports.object({
+  identityId: external_exports.string().trim().min(1),
+  provider: external_exports.string().trim().min(1),
+  connection: external_exports.string().trim().min(1),
+  workspace: external_exports.string().trim().min(1),
+  realized: external_exports.boolean(),
+  appId: external_exports.string().trim().min(1).optional(),
+  botUserId: external_exports.string().trim().min(1).optional(),
+  teamId: external_exports.string().trim().min(1).optional(),
+  // Telegram-realized identities: the persona bot's @username and lifecycle
+  // state (creation is human-confirmed in Telegram, so identities can sit
+  // `pending` between the connect step and the managed_bot webhook).
+  botUsername: external_exports.string().trim().min(1).optional(),
+  telegramStatus: AgentTelegramIdentityStatusSchema.optional(),
+  /**
+   * Telegram privacy-mode state verified during connect: true means privacy
+   * mode is disabled and the persona sees all group messages. Not writable
+   * via the Bot API — flipping it is a BotFather step (/setprivacy), or add
+   * the persona as a group admin.
+   */
+  canReadAllGroupMessages: external_exports.boolean().optional(),
+  // Avatar drift surface: the agent's desired avatar hash + public URL, and
+  // the hash last confirmed applied to the provider app icon. Providers offer
+  // no API for app icons, so application is a guided manual step recorded via
+  // the presence icon endpoint.
+  avatarSha256: external_exports.string().regex(SHA256_HEX_PATTERN).optional(),
+  avatarUrl: external_exports.string().trim().min(1).optional(),
+  appliedIconSha256: external_exports.string().regex(SHA256_HEX_PATTERN).optional(),
+  /**
+   * Scopes the current agent-app scope set requests that this realized
+   * identity's install never granted. Computed at read time; non-empty means
+   * the install predates a scope addition and `auto agents connect
+   * <agent> --reconnect` refreshes it.
+   */
+  missingScopes: external_exports.array(external_exports.string().trim().min(1)).optional()
+});
+var AgentPresenceResponseSchema = external_exports.object({
+  agent: ResourceNameSchema,
+  identities: external_exports.array(AgentPresenceIdentitySchema)
+});
+var AgentPresenceConnectRequestSchema = external_exports.object({
+  /**
+   * Rerun the install OAuth for already-realized identities too. The repair
+   * path for a stranded bot token (e.g. the single-use refresh token was
+   * consumed but the rotated pair failed to persist): the stored app
+   * credentials are reused, so this never creates a new Slack app.
+   */
+  reconnect: external_exports.boolean().default(false)
+});
+var AgentPresenceConnectPendingSchema = external_exports.object({
+  identityId: external_exports.string().trim().min(1),
+  connection: external_exports.string().trim().min(1),
+  workspace: external_exports.string().trim().min(1),
+  /**
+   * The URL the operator opens to realize this identity: the Slack install
+   * authorize URL, or the Telegram managed-bot creation deep link.
+   */
+  authorizationUrl: external_exports.string().trim().url(),
+  /**
+   * Telegram only: the pre-filled bot username in the creation dialog. The
+   * user can edit it there, so it is a suggestion, not the final identity.
+   */
+  suggestedUsername: external_exports.string().trim().min(1).optional()
+});
+var AgentPresenceConnectResponseSchema = external_exports.object({
+  agent: ResourceNameSchema,
+  pending: external_exports.array(AgentPresenceConnectPendingSchema),
+  realized: external_exports.array(AgentPresenceIdentitySchema),
+  message: external_exports.string().trim().min(1)
+});
+var AgentPresenceIconRequestSchema = external_exports.object({
+  sha256: external_exports.string().regex(SHA256_HEX_PATTERN)
+});
+var AgentPresenceIconResponseSchema = external_exports.object({
+  agent: ResourceNameSchema,
+  identityId: external_exports.string().trim().min(1),
+  appliedIconSha256: external_exports.string().regex(SHA256_HEX_PATTERN)
+});
+var AgentPresenceCompleteResponseSchema = external_exports.object({
+  status: external_exports.literal("connected"),
+  agent: ResourceNameSchema,
+  connection: external_exports.string().trim().min(1),
+  workspace: external_exports.string().trim().min(1),
+  organizationId: external_exports.string().trim().min(1),
+  botUserId: external_exports.string().trim().min(1)
+});
+function validateAttachedUserPrompt(trigger, context, guard) {
+  if (guard === "authoring" && trigger.attachedUserPrompt !== void 0 && !routeCanSpawn(trigger.route)) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["attachedUserPrompt"],
+      message: "Attached user prompt is supported only for routes that can spawn a session"
+    });
+  }
+}
+function routeCanSpawn(route) {
+  return route.to === "new" || (route.to === "slot" || typeof route.to === "object") && route.onUnmatched === "spawn";
+}
+function validateTriggerChecks(trigger, context, eventKeys) {
+  const checks = trigger.checks ?? [];
+  if (checks.length === 0) {
+    return;
+  }
+  if (eventKeys.some((event) => !event.startsWith("github.pull_request."))) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["checks"],
+      message: "Trigger checks are only supported for GitHub pull request events"
+    });
+  }
+  const names = /* @__PURE__ */ new Set();
+  const displayNames = /* @__PURE__ */ new Set();
+  for (const [index, check2] of checks.entries()) {
+    if (names.has(check2.name)) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["checks", index, "name"],
+        message: "Trigger check names must be unique"
+      });
+    }
+    names.add(check2.name);
+    if (displayNames.has(check2.displayName)) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["checks", index, "displayName"],
+        message: "Trigger check display names must be unique"
+      });
+    }
+    displayNames.add(check2.displayName);
+  }
+}
+function expandTriggerDefinitions(triggers) {
+  const expanded = [];
+  for (const trigger of triggers) {
+    if (trigger.kind === "heartbeat") {
+      expanded.push(trigger);
+      continue;
+    }
+    const { events, ...singleTrigger } = trigger;
+    for (const event of trigger.event ? [trigger.event] : events ?? []) {
+      expanded.push({
+        ...singleTrigger,
+        event
+      });
+    }
+  }
+  return expanded;
+}
+function expandApplyTriggerDefinitions(triggers) {
+  const expanded = [];
+  for (const trigger of triggers) {
+    if (trigger.kind === "heartbeat") {
+      expanded.push(trigger);
+      continue;
+    }
+    const { events, ...singleTrigger } = trigger;
+    for (const event of trigger.event ? [trigger.event] : events ?? []) {
+      expanded.push({
+        ...singleTrigger,
+        event
+      });
+    }
+  }
+  return expanded;
+}
+function validateAttributedRunsTriggerPairing(triggers, context) {
+  for (const [index, trigger] of triggers.entries()) {
+    if (trigger.kind === "heartbeat" || !trigger.event) {
+      continue;
+    }
+    const eventTrigger = trigger;
+    if (!isAttributedSessionsDeliverTrigger(eventTrigger) || !isChatMessageEvent(eventTrigger)) {
+      continue;
+    }
+    if (hasFilterValue(eventTrigger, "$.auto.authored", false)) {
+      continue;
+    }
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: [index, "where", "$.auto.authored"],
+      message: 'Chat thread routes must filter out Auto-authored messages with "$.auto.authored": false.'
+    });
+  }
+  for (const [spawnIndex, spawnTrigger] of triggers.entries()) {
+    if (spawnTrigger.kind === "heartbeat" || !spawnTrigger.event) {
+      continue;
+    }
+    if (!isSpawnTrigger(spawnTrigger)) {
+      continue;
+    }
+    for (const [deliverIndex, deliverTrigger] of triggers.entries()) {
+      if (deliverTrigger.kind === "heartbeat" || !deliverTrigger.event || spawnIndex === deliverIndex || spawnTrigger.event !== deliverTrigger.event || !isAttributedSessionsDeliverTrigger(deliverTrigger)) {
+        continue;
+      }
+      if (hasAutoAttributionsExists(spawnTrigger, false) && hasAutoAttributionsExists(deliverTrigger, true)) {
+        continue;
+      }
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: [deliverIndex, "route"],
+        message: 'Overlapping spawn and chat thread routes on the same event must use mutually exclusive "$.auto.attributions" filters: spawn requires { exists: false }, delivery requires { exists: true }.'
+      });
+    }
+  }
+}
+function isSpawnTrigger(trigger) {
+  return routeCanSpawn(trigger.route);
+}
+function isAttributedSessionsDeliverTrigger(trigger) {
+  return typeof trigger.route.to === "object" && trigger.route.to.target === "chat.thread";
+}
+function hasAutoAttributionsExists(trigger, expected) {
+  const clause = trigger.where?.["$.auto.attributions"];
+  return clause !== null && typeof clause === "object" && !Array.isArray(clause) && Reflect.get(clause, "exists") === expected;
+}
+function isChatMessageEvent(trigger) {
+  return trigger.event.startsWith("chat.message.");
+}
+function hasFilterValue(trigger, path2, expected) {
+  return trigger.where?.[path2] === expected;
+}
 
 // ../../packages/schemas/src/requester.ts
 var RequesterOriginSchema = external_exports.discriminatedUnion("kind", [
@@ -36224,6 +39420,125 @@ var SessionCommandRecordSchema = external_exports.discriminatedUnion("kind", [
   })
 ]);
 
+// ../../packages/schemas/src/validation-diagnostics.ts
+var AUTO_VALIDATION_DIAGNOSTIC_CATALOG_VERSION = 1;
+var AUTO_VALIDATION_DIAGNOSTIC_CATALOG = {
+  "auto.validation.input.dialect_conflict": {
+    severity: "error",
+    message: "Choose exactly one supported validation input dialect.",
+    owner: "schemas/project-apply"
+  },
+  "auto.validation.input.invalid_shape": {
+    severity: "error",
+    message: "The validation input does not match the selected dialect.",
+    owner: "schemas/project-apply"
+  },
+  "auto.validation.authoring.facade_required": {
+    severity: "error",
+    message: "This file uses a typed resource envelope where an authoring facade is required.",
+    owner: "schemas/project-apply-files"
+  },
+  "auto.validation.parse.yaml_invalid": {
+    severity: "error",
+    message: "The Auto authoring file could not be parsed as YAML or JSON.",
+    owner: "schemas/project-apply-files"
+  },
+  "auto.validation.schema_version.invalid": {
+    severity: "error",
+    message: "The authored schema version must be a positive integer.",
+    owner: "schemas/project-apply-files"
+  },
+  "auto.validation.schema_version.unsupported": {
+    severity: "error",
+    message: "This Auto release does not support the authored schema version.",
+    owner: "schemas/project-apply-files"
+  },
+  "auto.validation.authoring.unknown_field": {
+    severity: "error",
+    message: "The versioned authoring document contains an unknown field.",
+    owner: "schemas/project-apply-files"
+  },
+  "auto.validation.schema.invalid": {
+    severity: "error",
+    message: "The Auto resource does not match its schema.",
+    owner: "schemas/project-apply-files"
+  },
+  "auto.validation.legacy.unknown": {
+    severity: "error",
+    message: "Auto validation failed without a recognized diagnostic code.",
+    owner: "schemas/project-apply"
+  }
+};
+var AUTO_VALIDATION_DIAGNOSTIC_CODES = Object.freeze(
+  Object.keys(AUTO_VALIDATION_DIAGNOSTIC_CATALOG)
+);
+var AutoValidationDiagnosticSchema = external_exports.object({
+  catalogVersion: external_exports.number().int().positive(),
+  // Keep readers forward-compatible with codes added by a newer producer.
+  // Catalog membership is enforced when this version creates diagnostics.
+  code: external_exports.string().min(1),
+  severity: external_exports.enum(["error", "warning", "info"]),
+  blocking: external_exports.boolean(),
+  message: external_exports.string().min(1),
+  path: external_exports.array(external_exports.union([external_exports.string(), external_exports.number().int()])).optional(),
+  location: external_exports.object({
+    file: external_exports.string().min(1),
+    line: external_exports.number().int().positive().optional(),
+    column: external_exports.number().int().positive().optional(),
+    documentIndex: external_exports.number().int().nonnegative().optional()
+  }).optional(),
+  remediation: external_exports.object({
+    summary: external_exports.string().min(1),
+    correctedCall: JsonValueSchema2.optional()
+  }).optional()
+});
+function autoValidationDiagnostic(input) {
+  const catalogEntry = AUTO_VALIDATION_DIAGNOSTIC_CATALOG[input.code];
+  return AutoValidationDiagnosticSchema.parse({
+    catalogVersion: AUTO_VALIDATION_DIAGNOSTIC_CATALOG_VERSION,
+    code: input.code,
+    severity: catalogEntry.severity,
+    blocking: input.blocking ?? true,
+    message: catalogEntry.message,
+    ...input.path ? { path: input.path } : {},
+    ...input.location ? { location: input.location } : {},
+    ...input.remediation ? { remediation: input.remediation } : {}
+  });
+}
+var AutoValidationDiagnosticError = class extends Error {
+  diagnostic;
+  // Compiler-owned, content-free provenance for immediate telemetry. Keep it
+  // off the serialized diagnostic contract and immutable after first resolve.
+  #authoringOrigin;
+  constructor(message, diagnostic) {
+    super(message);
+    this.name = "AutoValidationDiagnosticError";
+    this.diagnostic = diagnostic;
+  }
+  get authoringOrigin() {
+    return this.#authoringOrigin;
+  }
+  withAuthoringOrigin(origin) {
+    this.#authoringOrigin ??= origin;
+    return this;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      diagnostic: this.diagnostic
+    };
+  }
+};
+function autoValidationDiagnosticFromError(error51) {
+  if (error51 instanceof AutoValidationDiagnosticError) {
+    return error51.diagnostic;
+  }
+  return autoValidationDiagnostic({
+    code: "auto.validation.legacy.unknown"
+  });
+}
+
 // ../../packages/schemas/src/runtime-log.ts
 var RUNTIME_LOG_LEVELS = ["debug", "info", "warn", "error"];
 var RuntimeLogLevelSchema = external_exports.enum(RUNTIME_LOG_LEVELS);
@@ -71600,6 +74915,220 @@ function one(e, t) {
   return null;
 }
 
+// ../../packages/schemas/src/project-apply-files/source.ts
+var import_yaml = __toESM(require_dist(), 1);
+
+// ../../packages/schemas/src/project-apply-files/schema-version.ts
+var CURRENT_AUTHORED_SCHEMA_VERSION = 1;
+var LEGACY_AUTHORED_SCHEMA_DIALECT = Object.freeze({
+  kind: "legacy"
+});
+var AUTHORED_SCHEMA_MIGRATIONS = Object.freeze([]);
+var CURRENT_AUTHORED_SCHEMA_DIALECT = Object.freeze({
+  kind: "versioned",
+  version: CURRENT_AUTHORED_SCHEMA_VERSION
+});
+function selectAuthoredSchemaDocument(input) {
+  if (!isRecord(input.document) || !Object.hasOwn(input.document, "schemaVersion")) {
+    return {
+      dialect: LEGACY_AUTHORED_SCHEMA_DIALECT,
+      value: input.document
+    };
+  }
+  const version2 = input.document.schemaVersion;
+  if (typeof version2 !== "number" || !isPositiveInteger(version2)) {
+    throw malformedSchemaVersionError(input);
+  }
+  if (version2 > CURRENT_AUTHORED_SCHEMA_VERSION) {
+    throw unsupportedSchemaVersionError(input, version2);
+  }
+  const { schemaVersion: _controlField, ...body } = input.document;
+  return {
+    dialect: CURRENT_AUTHORED_SCHEMA_DIALECT,
+    value: migrateAuthoredSchemaDocument({
+      document: body,
+      fromVersion: version2,
+      toVersion: CURRENT_AUTHORED_SCHEMA_VERSION,
+      migrations: AUTHORED_SCHEMA_MIGRATIONS
+    })
+  };
+}
+function migrateAuthoredSchemaDocument(input) {
+  if (!isPositiveInteger(input.fromVersion) || !isPositiveInteger(input.toVersion)) {
+    throw new Error(
+      "Authored schema migration endpoints must be positive integers"
+    );
+  }
+  if (input.fromVersion > input.toVersion) {
+    throw new Error(
+      `Authored schema migrations cannot move backward from ${input.fromVersion} to ${input.toVersion}`
+    );
+  }
+  let document2 = structuredClone(input.document);
+  for (let version2 = input.fromVersion; version2 < input.toVersion; version2 += 1) {
+    const edges = input.migrations.filter(
+      (edge) => edge.fromVersion === version2
+    );
+    if (edges.length !== 1 || edges[0]?.toVersion !== version2 + 1) {
+      throw new Error(
+        `Authored schema migration chain requires exactly one ${version2} -> ${version2 + 1} edge`
+      );
+    }
+    document2 = edges[0].migrate(structuredClone(document2));
+  }
+  return document2;
+}
+function malformedSchemaVersionError(input) {
+  return new AutoValidationDiagnosticError(
+    `Invalid schemaVersion in ${documentLabel(input)}: expected a positive integer`,
+    autoValidationDiagnostic({
+      code: "auto.validation.schema_version.invalid",
+      path: ["schemaVersion"],
+      location: diagnosticLocation(input),
+      remediation: {
+        summary: `Set schemaVersion to ${CURRENT_AUTHORED_SCHEMA_VERSION}, or remove it to retain the legacy dialect.`
+      }
+    })
+  );
+}
+function unsupportedSchemaVersionError(input, version2) {
+  return new AutoValidationDiagnosticError(
+    `Unsupported schemaVersion ${version2} in ${documentLabel(input)}: this Auto release supports through ${CURRENT_AUTHORED_SCHEMA_VERSION}`,
+    autoValidationDiagnostic({
+      code: "auto.validation.schema_version.unsupported",
+      path: ["schemaVersion"],
+      location: diagnosticLocation(input),
+      remediation: {
+        summary: "Upgrade Auto to a release that supports this authored schema version, then validate again."
+      }
+    })
+  );
+}
+function documentLabel(input) {
+  return `${input.location.file} document ${input.documentIndex + 1}`;
+}
+function diagnosticLocation(input) {
+  return {
+    ...input.topLevelLocations.schemaVersion ?? input.location,
+    documentIndex: input.documentIndex
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && value > 0;
+}
+
+// ../../packages/schemas/src/project-apply-files/source.ts
+var APPLY_DIRECTORIES = {
+  [RESOURCE_KIND_AGENT]: "agents"
+};
+var PROJECT_APPLY_RESOURCE_DIRECTORIES = Object.freeze([
+  APPLY_DIRECTORIES[RESOURCE_KIND_AGENT]
+]);
+function readSourceDocuments(file2) {
+  const source = Buffer.from(file2.contentBase64, "base64").toString("utf8");
+  const lineCounter = new import_yaml.LineCounter();
+  let parsedDocuments;
+  try {
+    parsedDocuments = (0, import_yaml.parseAllDocuments)(source, {
+      keepSourceTokens: true,
+      lineCounter
+    });
+    const parseError = parsedDocuments.flatMap((document2) => document2.errors).at(0);
+    if (parseError) {
+      throw parseError;
+    }
+  } catch {
+    throw new AutoValidationDiagnosticError(
+      `Invalid apply file ${file2.path}: YAML or JSON could not be parsed`,
+      autoValidationDiagnostic({
+        code: "auto.validation.parse.yaml_invalid",
+        location: { file: file2.path },
+        remediation: {
+          summary: "Fix the YAML or JSON syntax in this file, then validate again."
+        }
+      })
+    );
+  }
+  return parsedDocuments.flatMap((document2, documentIndex) => {
+    if (document2.contents === null) {
+      return [];
+    }
+    const value = sourceDocumentValue(document2, file2.path);
+    const location = sourceNodeLocation(
+      document2.contents,
+      file2.path,
+      lineCounter
+    );
+    const topLevelLocations = topLevelSourceLocations(
+      document2.contents,
+      file2.path,
+      lineCounter
+    );
+    const selected = selectAuthoredSchemaDocument({
+      document: value,
+      documentIndex,
+      location,
+      topLevelLocations
+    });
+    return [
+      {
+        ...selected,
+        documentIndex,
+        location,
+        topLevelLocations
+      }
+    ];
+  });
+}
+function sourceDocumentValue(document2, file2) {
+  try {
+    return document2.toJSON();
+  } catch {
+    throw invalidSourceSyntaxError(file2);
+  }
+}
+function invalidSourceSyntaxError(file2) {
+  return new AutoValidationDiagnosticError(
+    `Invalid apply file ${file2}: YAML or JSON could not be parsed`,
+    autoValidationDiagnostic({
+      code: "auto.validation.parse.yaml_invalid",
+      location: { file: file2 },
+      remediation: {
+        summary: "Fix the YAML or JSON syntax in this file, then validate again."
+      }
+    })
+  );
+}
+function normalizeSourcePath(path2) {
+  return path2.replaceAll("\\", "/").replace(/^\/+|\/+$/g, "");
+}
+function topLevelSourceLocations(node, file2, lineCounter) {
+  if (!(0, import_yaml.isMap)(node)) {
+    return {};
+  }
+  return Object.fromEntries(
+    node.items.flatMap((pair) => {
+      const key = pair.key?.toJSON?.();
+      if (typeof key !== "string") {
+        return [];
+      }
+      return [[key, sourceNodeLocation(pair.key, file2, lineCounter)]];
+    })
+  );
+}
+function sourceNodeLocation(node, file2, lineCounter) {
+  const range = node?.range;
+  const position = lineCounter.linePos(range?.[0] ?? 0);
+  return {
+    file: normalizeSourcePath(file2),
+    line: position.line,
+    column: position.col
+  };
+}
+
 // ../../node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 var LATEST_PROTOCOL_VERSION = "2025-11-25";
 var DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
@@ -73121,9 +76650,6 @@ var UrlElicitationRequiredError = class extends McpError {
   }
 };
 
-// src/commands/agent-bridge/harness/agent-facing-auto-mcp.ts
-var import_yaml = __toESM(require_dist(), 1);
-
 // src/lib/project-apply-filesystem-source.ts
 import { readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
 import { basename as basename3, dirname as dirname4, join as join5, relative as relative2, resolve as resolve5 } from "path";
@@ -73286,12 +76812,12 @@ async function createClaudeAutoMcpServer(input) {
   });
   const transformed = input.transformDryRun ? transformToolsListResponse(JSON.stringify(listResponse)) : { body: JSON.stringify(listResponse), pathsCompatible: false };
   const listed = JSON.parse(transformed.body);
-  if (isRecord(listed.error)) {
+  if (isRecord3(listed.error)) {
     throw new AgentBridgeTerminalPrepareError(
       typeof listed.error.message === "string" ? listed.error.message : `Auto MCP server ${input.name} failed tools/list`
     );
   }
-  const result = isRecord(listed.result) ? listed.result : {};
+  const result = isRecord3(listed.result) ? listed.result : {};
   const tools = Array.isArray(result.tools) ? result.tools : [];
   const sdkServer = tJe({ name: input.name, version: "1" });
   sdkServer.instance.server.registerCapabilities({ tools: {} });
@@ -73324,7 +76850,7 @@ async function createClaudeAutoMcpServer(input) {
         message,
         commandId: exactActiveCommandId(input.activeTurnCommandIds)
       });
-      if (isRecord(response.error)) {
+      if (isRecord3(response.error)) {
         return {
           content: [
             {
@@ -73364,7 +76890,7 @@ function parseJsonRpcResponseBody(body) {
     }
     try {
       const candidate = JSON.parse(line.slice("data:".length).trim());
-      if (isRecord(candidate)) {
+      if (isRecord3(candidate)) {
         parsed = candidate;
       }
     } catch {
@@ -73376,7 +76902,7 @@ function parseJsonRpcResponseBody(body) {
   return parsed;
 }
 function asCallToolResult(value) {
-  if (isRecord(value) && Array.isArray(value.content)) {
+  if (isRecord3(value) && Array.isArray(value.content)) {
     return value;
   }
   return {
@@ -73384,7 +76910,7 @@ function asCallToolResult(value) {
   };
 }
 function agentFacingDryRunTool(tool) {
-  if (!isRecord(tool) || tool.name !== DRY_RUN_TOOL_NAME) {
+  if (!isRecord3(tool) || tool.name !== DRY_RUN_TOOL_NAME) {
     return tool;
   }
   if (typeof tool.description !== "string" || !tool.description.includes(AUTO_RESOURCES_DRY_RUN_PATHS_PROTOCOL_MARKER)) {
@@ -73413,7 +76939,7 @@ function agentFacingDryRunTool(tool) {
   };
 }
 function resolveAgentFacingDryRun(input) {
-  if (!isRecord(input.arguments)) {
+  if (!isRecord3(input.arguments)) {
     throw new Error(`Dry-run arguments must be an object. ${correctedCall}`);
   }
   const argumentsValue = input.arguments;
@@ -73571,9 +77097,12 @@ function readContainedTextFile(cwdRoot, path2) {
 }
 function localImportPaths(content, importerPath) {
   const imports = [];
-  for (const document2 of (0, import_yaml.parseAllDocuments)(content)) {
-    const value = document2.toJS();
-    if (!isRecord(value) || !Array.isArray(value.imports)) {
+  for (const document2 of readSourceDocuments({
+    path: importerPath,
+    contentBase64: Buffer.from(content, "utf8").toString("base64")
+  })) {
+    const value = document2.value;
+    if (!isRecord3(value) || !Array.isArray(value.imports)) {
       continue;
     }
     for (const importPath of value.imports) {
@@ -73745,8 +77274,8 @@ async function startAutoMcpProxy(input) {
   return { server, url: `http://127.0.0.1:${address.port}/mcp` };
 }
 function prepareDryRunToolCall(input) {
-  const params = isRecord(input.message.params) ? input.message.params : {};
-  const argumentsValue = isRecord(params.arguments) ? params.arguments : {};
+  const params = isRecord3(input.message.params) ? input.message.params : {};
+  const argumentsValue = isRecord3(params.arguments) ? params.arguments : {};
   const hasLegacyDialect = ["files", "resources"].some(
     (key) => Object.hasOwn(argumentsValue, key)
   );
@@ -73781,6 +77310,15 @@ function prepareDryRunToolCall(input) {
     if (error51 instanceof Error && error51.message === "legacy-pass-through") {
       return { kind: "forward", message: input.message };
     }
+    if (error51 instanceof AutoValidationDiagnosticError) {
+      return toolError(
+        input.message.id,
+        JSON.stringify({
+          error: error51.message,
+          diagnostic: autoValidationDiagnosticFromError(error51)
+        })
+      );
+    }
     return toolError(
       input.message.id,
       error51 instanceof Error ? error51.message : String(error51)
@@ -73791,7 +77329,7 @@ function transformToolsListResponse(body) {
   const parsed = JSON.parse(body);
   let compatible = false;
   const transformed = transformJsonRpcMessages(parsed, (message) => {
-    if (!isRecord(message.result) || !Array.isArray(message.result.tools)) {
+    if (!isRecord3(message.result) || !Array.isArray(message.result.tools)) {
       return message;
     }
     const tools = message.result.tools.map((tool) => {
@@ -73808,16 +77346,16 @@ function transformToolsListResponse(body) {
 function transformJsonRpcMessages(value, transform2) {
   if (Array.isArray(value)) {
     return value.map(
-      (message) => isRecord(message) ? transform2(message) : message
+      (message) => isRecord3(message) ? transform2(message) : message
     );
   }
-  return isRecord(value) ? transform2(value) : value;
+  return isRecord3(value) ? transform2(value) : value;
 }
 function isToolsListRequest(value) {
-  return isRecord(value) && value.method === "tools/list";
+  return isRecord3(value) && value.method === "tools/list";
 }
 function isDryRunToolCall(value) {
-  if (!isRecord(value) || value.method !== "tools/call" || !isRecord(value.params)) {
+  if (!isRecord3(value) || value.method !== "tools/call" || !isRecord3(value.params)) {
     return false;
   }
   return value.params.name === DRY_RUN_TOOL_NAME;
@@ -73890,7 +77428,7 @@ function writeResponse(response, status, headers, body) {
   }
   response.end(body);
 }
-function isRecord(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -77576,12 +81114,12 @@ function canonicalizeMcpResultValue(value) {
   if (typeof value !== "object" || value === null) {
     return { value, deduplicatedBranches: 0 };
   }
-  const record2 = value;
-  const duplicateContentIndexes = equivalentMcpTextContentIndexes(record2);
+  const record3 = value;
+  const duplicateContentIndexes = equivalentMcpTextContentIndexes(record3);
   let deduplicatedBranches = duplicateContentIndexes.size;
   let changed = duplicateContentIndexes.size > 0;
   const canonical = /* @__PURE__ */ Object.create(null);
-  for (const [key, item] of Object.entries(record2)) {
+  for (const [key, item] of Object.entries(record3)) {
     if (key === "content" && Array.isArray(item)) {
       const retainedContent = duplicateContentIndexes.size > 0 ? item.filter(
         (_contentItem, index) => !duplicateContentIndexes.has(index)
@@ -77625,9 +81163,9 @@ function isPlainMcpTextBlock(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
   }
-  const record2 = value;
-  const keys = Object.keys(record2);
-  return keys.length === 2 && record2.type === "text" && typeof record2.text === "string";
+  const record3 = value;
+  const keys = Object.keys(record3);
+  return keys.length === 2 && record3.type === "text" && typeof record3.text === "string";
 }
 function parseJson(value) {
   try {
@@ -79948,15 +83486,15 @@ function fileClaudeSessionResumeStore(path2 = CLAUDE_SESSION_RESUME_PATH) {
       if (!existsSync2(path2)) {
         return null;
       }
-      const record2 = parseResumeRecord(readFileSync4(path2, "utf8"));
-      if (!record2 || record2.sessionId !== sessionId) {
+      const record3 = parseResumeRecord(readFileSync4(path2, "utf8"));
+      if (!record3 || record3.sessionId !== sessionId) {
         return null;
       }
-      return record2.agentId;
+      return record3.agentId;
     },
-    write(record2) {
+    write(record3) {
       mkdirSync2(dirname5(path2), { recursive: true });
-      writeFileSync(path2, `${JSON.stringify(record2)}
+      writeFileSync(path2, `${JSON.stringify(record3)}
 `, "utf8");
     }
   };
@@ -80084,15 +83622,15 @@ function fileClaudeReadStateStore(path2 = CLAUDE_READ_STATE_PATH) {
       if (!existsSync3(path2)) {
         return null;
       }
-      const record2 = parseReadStateRecord(readFileSync5(path2, "utf8"));
-      if (!record2 || record2.sessionId !== sessionId) {
+      const record3 = parseReadStateRecord(readFileSync5(path2, "utf8"));
+      if (!record3 || record3.sessionId !== sessionId) {
         return null;
       }
-      return record2.entries;
+      return record3.entries;
     },
-    write(record2) {
+    write(record3) {
       mkdirSync3(dirname6(path2), { recursive: true });
-      writeFileSync2(path2, `${JSON.stringify(record2)}
+      writeFileSync2(path2, `${JSON.stringify(record3)}
 `, "utf8");
     }
   };
@@ -82414,15 +85952,15 @@ function fileCodexThreadResumeStore(path2 = CODEX_THREAD_RESUME_PATH) {
       if (!existsSync4(path2)) {
         return null;
       }
-      const record2 = parseResumeRecord2(readFileSync6(path2, "utf8"));
-      if (!record2 || record2.sessionId !== sessionId) {
+      const record3 = parseResumeRecord2(readFileSync6(path2, "utf8"));
+      if (!record3 || record3.sessionId !== sessionId) {
         return null;
       }
-      return record2.threadId;
+      return record3.threadId;
     },
-    write(record2) {
+    write(record3) {
       mkdirSync4(dirname7(path2), { recursive: true });
-      writeFileSync3(path2, `${JSON.stringify(record2)}
+      writeFileSync3(path2, `${JSON.stringify(record3)}
 `, "utf8");
     }
   };
@@ -83946,11 +87484,11 @@ function idFromResult(result, field) {
   if (result === null || typeof result !== "object") {
     return null;
   }
-  const record2 = Reflect.get(result, field);
-  if (record2 === null || typeof record2 !== "object") {
+  const record3 = Reflect.get(result, field);
+  if (record3 === null || typeof record3 !== "object") {
     return null;
   }
-  const id = Reflect.get(record2, "id");
+  const id = Reflect.get(record3, "id");
   return typeof id === "string" && id.length > 0 ? id : null;
 }
 function errorMessage8(error51) {