agent-valley 2.3.1 → 3.0.1

package/dist/supervisor.js

@@ -828,6 +828,35 @@ function formatError(error, mapper = (issue) => issue.message) {
   processError(error);
   return fieldErrors;
 }
+function toDotPath(_path) {
+  const segs = [];
+  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path) {
+    if (typeof seg === "number")
+      segs.push(`[${seg}]`);
+    else if (typeof seg === "symbol")
+      segs.push(`[${JSON.stringify(String(seg))}]`);
+    else if (/[^\w$]/.test(seg))
+      segs.push(`[${JSON.stringify(seg)}]`);
+    else {
+      if (segs.length)
+        segs.push(".");
+      segs.push(seg);
+    }
+  }
+  return segs.join("");
+}
+function prettifyError(error) {
+  const lines = [];
+  const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
+  for (const issue of issues) {
+    lines.push(`✖ ${issue.message}`);
+    if (issue.path?.length)
+      lines.push(`  → at ${toDotPath(issue.path)}`);
+  }
+  return lines.join(`
+`);
+}
 var _messageDesc, _issuesDesc, _installedToString, initializer = (inst, def) => {
   inst.name = "$ZodError";
   _issuesDesc.value = def;
@@ -921,7 +950,7 @@ var _parse = (_Err) => {
     return result.value;
   };
   return fn;
-}, _parseAsync = (_Err) => {
+}, parse, _parseAsync = (_Err) => {
   const fn = async (schema, value, _ctx, params) => {
     const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
     let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -935,7 +964,7 @@ var _parse = (_Err) => {
     return result.value;
   };
   return fn;
-}, _safeParse = (_Err) => (schema, value, _ctx) => {
+}, parseAsync, _safeParse = (_Err) => (schema, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
   const result = schema._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) {
@@ -1002,7 +1031,10 @@ var _parse = (_Err) => {
 };
 var init_parse = __esm(() => {
   init_core();
+  init_errors();
   init_util();
+  parse = /* @__PURE__ */ _parse($ZodRealError);
+  parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
   COMPILE_INVALID = /* @__PURE__ */ Symbol.for("zod.compile.invalid");
   COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for("zod.compile.fallback");
 });
@@ -1037,7 +1069,7 @@ var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, guid, uuid = (version) => {
   if (!version)
     return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
   return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
-}, email, _emoji = `^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`, ipv4, ipv6, cidrv4, cidrv6, base64, base64url, httpProtocol, e164, dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date, anyString, integer, number, boolean, _null, lowercase, uppercase;
+}, email, _emoji = `^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`, ipv4, ipv6, cidrv4, cidrv6, base64, base64url, httpProtocol, e164, dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date, anyString, bigint, integer, number, boolean, _null, lowercase, uppercase;
 var init_regexes = __esm(() => {
   cuid = /^[cC][0-9a-z]{6,}$/;
   cuid2 = /^[0-9a-z]+$/;
@@ -1058,6 +1090,7 @@ var init_regexes = __esm(() => {
   e164 = /^\+[1-9]\d{6,14}$/;
   date = /* @__PURE__ */ anchor(dateSource);
   anyString = /^[\s\S]{0,}$/;
+  bigint = /^-?\d+n?$/;
   integer = /^-?\d+$/;
   number = /^-?\d+(?:\.\d+)?$/;
   boolean = /^(?:true|false)$/i;
@@ -1866,7 +1899,7 @@ function handleRefineResult(result, payload, input, inst) {
     payload.issues.push(issue(_iss));
   }
 }
-var $ZodType, toStandardResult = (r, ctx) => r.issues.length ? { issues: r.issues.map((iss) => finalizeIssue(iss, ctx, config())) } : { value: r.value }, $ZodString, $ZodStringFormat, $ZodGUID, $ZodUUID, $ZodEmail, URL_BAD_FORMAT = 1, URL_UNPARSEABLE = 2, asciiTabOrNewline, $ZodURL, $ZodEmoji, $ZodNanoID, $ZodCUID, $ZodCUID2, $ZodULID, $ZodXID, $ZodKSUID, $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration, $ZodIPv4, ipv6Alphabet, $ZodIPv6, $ZodCIDRv4, $ZodCIDRv6, base64Charset, $ZodBase64, base64urlCharset, $ZodBase64URL, $ZodE164, $ZodJWT, $ZodNumber, $ZodNumberFormat, $ZodBoolean, $ZodNull, $ZodAny, $ZodUnknown, $ZodNever, $ZodArray, NO_SYMBOL_KEYS, $ZodObject, $ZodObjectJIT, $ZodUnion, $ZodDiscriminatedUnion, $ZodIntersection, $ZodRecord, $ZodEnum, $ZodLiteral, $ZodTransform, $ZodOptional, $ZodExactOptional, $ZodNullable, $ZodDefault, $ZodPrefault, $ZodNonOptional, $ZodCatch, $ZodPipe, $ZodPreprocess, $ZodReadonly, $ZodLazy, $ZodCustom;
+var $ZodType, toStandardResult = (r, ctx) => r.issues.length ? { issues: r.issues.map((iss) => finalizeIssue(iss, ctx, config())) } : { value: r.value }, $ZodString, $ZodStringFormat, $ZodGUID, $ZodUUID, $ZodEmail, URL_BAD_FORMAT = 1, URL_UNPARSEABLE = 2, asciiTabOrNewline, $ZodURL, $ZodEmoji, $ZodNanoID, $ZodCUID, $ZodCUID2, $ZodULID, $ZodXID, $ZodKSUID, $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration, $ZodIPv4, ipv6Alphabet, $ZodIPv6, $ZodCIDRv4, $ZodCIDRv6, base64Charset, $ZodBase64, base64urlCharset, $ZodBase64URL, $ZodE164, $ZodJWT, $ZodNumber, $ZodNumberFormat, $ZodBoolean, $ZodBigInt, $ZodNull, $ZodAny, $ZodUnknown, $ZodNever, $ZodDate, $ZodArray, NO_SYMBOL_KEYS, $ZodObject, $ZodObjectJIT, $ZodUnion, $ZodDiscriminatedUnion, $ZodIntersection, $ZodRecord, $ZodEnum, $ZodLiteral, $ZodTransform, $ZodOptional, $ZodExactOptional, $ZodNullable, $ZodDefault, $ZodPrefault, $ZodNonOptional, $ZodCatch, $ZodPipe, $ZodPreprocess, $ZodReadonly, $ZodLazy, $ZodCustom;
 var init_schemas = __esm(() => {
   init_checks();
   init_core();
@@ -2282,6 +2315,25 @@ var init_schemas = __esm(() => {
       return payload;
     };
   });
+  $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = bigint;
+    inst._zod.parse = (payload, _ctx) => {
+      if (def.coerce)
+        try {
+          payload.value = BigInt(payload.value);
+        } catch (_) {}
+      if (typeof payload.value === "bigint")
+        return payload;
+      payload.issues.push({
+        expected: "bigint",
+        code: "invalid_type",
+        input: payload.value,
+        inst
+      });
+      return payload;
+    };
+  });
   $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.pattern = _null;
@@ -2319,6 +2371,29 @@ var init_schemas = __esm(() => {
       return payload;
     };
   });
+  $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, _ctx) => {
+      if (def.coerce) {
+        try {
+          payload.value = new Date(payload.value);
+        } catch (_err) {}
+      }
+      const input = payload.value;
+      const isDate = input instanceof Date;
+      const isValidDate = isDate && !Number.isNaN(input.getTime());
+      if (isValidDate)
+        return payload;
+      payload.issues.push({
+        expected: "date",
+        code: "invalid_type",
+        input,
+        ...isDate ? { received: "Invalid Date" } : {},
+        inst
+      });
+      return payload;
+    };
+  });
   $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     $ZodType.init(inst, def);
     const memo = globalConfig.memoizer;
@@ -3597,6 +3672,9 @@ function snapshotChecks(def) {
 function _string(Class, params) {
   return new Class(snapshotChecks({ type: "string", ...normalizeParams(params) }));
 }
+function _coercedString(Class, params) {
+  return new Class(snapshotChecks({ type: "string", coerce: true, ...normalizeParams(params) }));
+}
 function _email(Class, params) {
   return new Class({
     type: "string",
@@ -3855,6 +3933,20 @@ function _boolean(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedBoolean(Class, params) {
+  return new Class({
+    type: "boolean",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
+function _coercedBigint(Class, params) {
+  return new Class({
+    type: "bigint",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
 function _null2(Class, params) {
   return new Class({
     type: "null",
@@ -3877,6 +3969,13 @@ function _never(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedDate(Class, params) {
+  return new Class({
+    type: "date",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
 function _lt(value, params) {
   return new $ZodCheckLessThan({
     check: "less_than",
@@ -4012,6 +4111,17 @@ function _array(Class, element, params) {
     ...normalizeParams(params)
   });
 }
+function _custom(Class, fn, _params) {
+  const norm = normalizeParams(_params);
+  norm.abort ?? (norm.abort = true);
+  const schema = new Class({
+    type: "custom",
+    check: "custom",
+    fn,
+    ...norm
+  });
+  return schema;
+}
 function _refine(Class, fn, _params) {
   const schema = new Class({
     type: "custom",
@@ -5291,6 +5401,7 @@ var init_core2 = __esm(() => {
   init_util();
   init_regexes();
   init_locales();
+  init_json_schema_processors();
   init_json_schema();
   init_core();
   init_parse();
@@ -5361,13 +5472,13 @@ var init_errors2 = __esm(() => {
 });
 
 // ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/classic/parse.js
-var parse2, parseAsync, safeParse, safeParseAsync, encode, decode, encodeAsync, decodeAsync, safeEncode, safeDecode, safeEncodeAsync, safeDecodeAsync;
+var parse3, parseAsync2, safeParse, safeParseAsync, encode, decode, encodeAsync, decodeAsync, safeEncode, safeDecode, safeEncodeAsync, safeDecodeAsync;
 var init_parse2 = __esm(() => {
   init_core2();
   init_errors2();
   init_core2();
-  parse2 = /* @__PURE__ */ _parse(ZodRealError);
-  parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
+  parse3 = /* @__PURE__ */ _parse(ZodRealError);
+  parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
   safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
   safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
   encode = /* @__PURE__ */ _encode(ZodRealError);
@@ -5395,6 +5506,9 @@ function string2(params) {
 function email2(params) {
   return _email(ZodEmail, params);
 }
+function uuid2(params) {
+  return _uuid(ZodUUID, params);
+}
 function url(params) {
   return _url(ZodURL, params);
 }
@@ -5574,6 +5688,9 @@ function lazy(getter) {
     getter
   });
 }
+function custom(fn, _params) {
+  return _custom(ZodCustom, fn ?? (() => true), _params);
+}
 function refine(fn, _params = {}) {
   return _refine(ZodCustom, fn, _params);
 }
@@ -5587,7 +5704,7 @@ function preprocess(fn, schema) {
     out: schema
   });
 }
-var ZodType, _ZodString, ZodString, ZodStringFormat, ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration, ZodEmail, ZodGUID, ZodUUID, ZodURL, ZodEmoji, ZodNanoID, ZodCUID, ZodCUID2, ZodULID, ZodXID, ZodKSUID, ZodIPv4, ZodIPv6, ZodCIDRv4, ZodCIDRv6, ZodBase64, ZodBase64URL, ZodE164, ZodJWT, ZodNumber, ZodNumberFormat, ZodBoolean, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodArray, ZodObject, ZodUnion, ZodDiscriminatedUnion, ZodIntersection, ZodRecord, ZodEnum, ZodLiteral, ZodTransform, ZodOptional, ZodExactOptional, ZodNullable, ZodDefault, ZodPrefault, ZodNonOptional, ZodCatch, ZodPipe, ZodPreprocess, ZodReadonly, ZodLazy, ZodCustom;
+var ZodType, _ZodString, ZodString, ZodStringFormat, ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration, ZodEmail, ZodGUID, ZodUUID, ZodURL, ZodEmoji, ZodNanoID, ZodCUID, ZodCUID2, ZodULID, ZodXID, ZodKSUID, ZodIPv4, ZodIPv6, ZodCIDRv4, ZodCIDRv6, ZodBase64, ZodBase64URL, ZodE164, ZodJWT, ZodNumber, ZodNumberFormat, ZodBoolean, ZodBigInt, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodDate, ZodArray, ZodObject, ZodUnion, ZodDiscriminatedUnion, ZodIntersection, ZodRecord, ZodEnum, ZodLiteral, ZodTransform, ZodOptional, ZodExactOptional, ZodNullable, ZodDefault, ZodPrefault, ZodNonOptional, ZodCatch, ZodPipe, ZodPreprocess, ZodReadonly, ZodLazy, ZodCustom;
 var init_schemas2 = __esm(() => {
   init_core2();
   init_core2();
@@ -5710,10 +5827,10 @@ var init_schemas2 = __esm(() => {
       own(this, "~standard", value);
     },
     parse: function _parse(data, params) {
-      return parse2(this, data, params, { callee: _parse });
+      return parse3(this, data, params, { callee: _parse });
     },
     parseAsync: async function _parseAsync(data, params) {
-      return await parseAsync(this, data, params, { callee: _parseAsync });
+      return await parseAsync2(this, data, params, { callee: _parseAsync });
     },
     safeParse(data, params) {
       return safeParse(this, data, params);
@@ -6076,6 +6193,49 @@ var init_schemas2 = __esm(() => {
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
   });
+  ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
+    $ZodBigInt.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => bigintProcessor(inst, ctx, json, params);
+  }, /* @__PURE__ */ derived({
+    minValue: (inst) => aggregateChecks(inst).minimum ?? null,
+    maxValue: (inst) => aggregateChecks(inst).maximum ?? null,
+    format: (inst) => aggregateChecks(inst).format ?? null
+  }, {
+    gte(value, params) {
+      return this.check(_gte(value, params));
+    },
+    min(value, params) {
+      return this.check(_gte(value, params));
+    },
+    gt(value, params) {
+      return this.check(_gt(value, params));
+    },
+    lt(value, params) {
+      return this.check(_lt(value, params));
+    },
+    lte(value, params) {
+      return this.check(_lte(value, params));
+    },
+    max(value, params) {
+      return this.check(_lte(value, params));
+    },
+    positive(params) {
+      return this.check(_gt(BigInt(0), params));
+    },
+    negative(params) {
+      return this.check(_lt(BigInt(0), params));
+    },
+    nonpositive(params) {
+      return this.check(_lte(BigInt(0), params));
+    },
+    nonnegative(params) {
+      return this.check(_gte(BigInt(0), params));
+    },
+    multipleOf(value, params) {
+      return this.check(_multipleOf(value, params));
+    }
+  }));
   ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
     $ZodNull.init(inst, def);
     ZodType.init(inst, def);
@@ -6096,6 +6256,22 @@ var init_schemas2 = __esm(() => {
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);
   });
+  ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
+    $ZodDate.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => dateProcessor(inst, ctx, json, params);
+    inst.min = (value, params) => inst.check(_gte(value, params));
+    inst.max = (value, params) => inst.check(_lte(value, params));
+  }, /* @__PURE__ */ derived({
+    minDate: (inst) => {
+      const { minimum } = aggregateChecks(inst);
+      return minimum ? new Date(minimum) : null;
+    },
+    maxDate: (inst) => {
+      const { maximum } = aggregateChecks(inst);
+      return maximum ? new Date(maximum) : null;
+    }
+  }, {}));
   ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
     _ensureDefaultMemoizer();
     $ZodArray.init(inst, def);
@@ -6402,9 +6578,29 @@ var init_iso = __esm(() => {
 });
 
 // ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/classic/coerce.js
+var exports_coerce = {};
+__export(exports_coerce, {
+  bigint: () => bigint2,
+  boolean: () => boolean3,
+  date: () => date3,
+  number: () => number3,
+  string: () => string3
+});
+function string3(params) {
+  return _coercedString(ZodString, params);
+}
 function number3(params) {
   return _coercedNumber(ZodNumber, params);
 }
+function boolean3(params) {
+  return _coercedBoolean(ZodBoolean, params);
+}
+function bigint2(params) {
+  return _coercedBigint(ZodBigInt, params);
+}
+function date3(params) {
+  return _coercedDate(ZodDate, params);
+}
 var init_coerce = __esm(() => {
   init_core2();
   init_schemas2();
@@ -6497,6 +6693,12 @@ var init_skill_matrix_schema = __esm(() => {
   });
 });
 
+// ../../packages/core/src/domain/agent.ts
+var AGENT_IDS;
+var init_agent = __esm(() => {
+  AGENT_IDS = ["claude", "codex", "qwen", "antigravity", "cursor", "grok", "kimi", "opencode"];
+});
+
 // ../../packages/core/src/config/task-schema.ts
 var reportPath, taskSchema, resolvedTaskSchema;
 var init_task_schema = __esm(() => {
@@ -6519,8 +6721,9 @@ function normalizeActorDefaults(config) {
 var actorTypeSchema, actorDefaultsSchema, routingRuleSchema, scoreRoutingTierSchema, scoreRoutingSchema;
 var init_actor_schema = __esm(() => {
   init_zod();
+  init_agent();
   init_task_schema();
-  actorTypeSchema = _enum(["claude", "codex", "qwen", "antigravity", "cursor", "grok", "kimi", "opencode"]);
+  actorTypeSchema = _enum(AGENT_IDS);
   actorDefaultsSchema = object({
     type: actorTypeSchema.optional(),
     model: string2().trim().min(1).max(256).optional(),
@@ -6758,6 +6961,108 @@ var init_container_observation_policy = __esm(() => {
   });
 });
 
+// ../../packages/core/src/chief/usage.ts
+function startOperatingRun(mission, actor, attempt, stage, taskId, routingReason) {
+  mission.operations ??= { runs: [], routingEvidence: [], reviewDecisions: [] };
+  const entry = {
+    runId: attempt.id,
+    ...taskId ? { taskId } : {},
+    stage,
+    actorId: actor.id,
+    actorType: actor.agentType,
+    ...actor.model ? { model: actor.model } : {},
+    startedAt: attempt.startedAt,
+    finishedAt: null,
+    elapsedMs: null,
+    inputTokens: null,
+    outputTokens: null,
+    costUsd: null,
+    outcome: "pending",
+    executionState: "running",
+    executionRecovery: "reconcile",
+    ...routingReason ? { routingReason } : {}
+  };
+  mission.operations.runs.push(entry);
+  return entry;
+}
+function markOperatingRunUnknown(entry, reason) {
+  entry.executionState = "unknown";
+  entry.finishedAt = null;
+  entry.outcome = "pending";
+  const detail = reason?.trim();
+  if (detail)
+    entry.evidence = detail.slice(-2000);
+}
+function finishOperatingRun(mission, entry, attempt, failed = false) {
+  entry.finishedAt = attempt.finishedAt ?? new Date().toISOString();
+  const elapsed = Date.parse(entry.finishedAt) - Date.parse(entry.startedAt);
+  entry.elapsedMs = Number.isFinite(elapsed) && elapsed >= 0 ? elapsed : null;
+  const usage = attempt.tokenUsage;
+  entry.costUsd = null;
+  delete entry.actualModel;
+  entry.inputTokens = tokens(usage?.input);
+  entry.outputTokens = tokens(usage?.output);
+  if (usage?.model)
+    entry.actualModel = usage.model.slice(0, 2000);
+  const candidate = mission.operatingPolicy?.routing?.candidates.find((item) => item.actorType === entry.actorType && item.model === entry.model);
+  if (candidate?.inputPerMillionUsd !== undefined && candidate.outputPerMillionUsd !== undefined && entry.inputTokens !== null && entry.outputTokens !== null && (!entry.model || !entry.actualModel || entry.model === entry.actualModel)) {
+    const estimate = (entry.inputTokens * candidate.inputPerMillionUsd + entry.outputTokens * candidate.outputPerMillionUsd) / 1e6;
+    entry.costUsd = Number.isFinite(estimate) ? estimate : null;
+  }
+  if (entry.executionState === "unknown") {
+    entry.finishedAt = null;
+    entry.outcome = "pending";
+  } else {
+    entry.executionState = "settled";
+    entry.outcome = failed ? "failed" : entry.stage === "work" ? "pending" : "passed";
+  }
+}
+var tokens = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+
+// ../../packages/core/src/chief/contracts.ts
+var executionPolicySchema, executionStateSchema;
+var init_contracts = __esm(() => {
+  init_zod();
+  executionPolicySchema = strictObject({
+    maxParallel: number2().int().min(1).max(8).default(3),
+    maxDurationSec: number2().int().min(1).max(604800).default(86400),
+    maxRuns: number2().int().min(1).max(2000).default(200),
+    maxEstimatedCostUsd: number2().finite().positive().optional(),
+    maxRetries: number2().int().min(0).max(10).default(3),
+    retryDelayMs: number2().int().min(10).max(300000).default(1000),
+    autoResume: boolean2().default(true)
+  });
+  executionStateSchema = strictObject({
+    startedAt: exports_iso.datetime(),
+    runsStarted: number2().int().nonnegative(),
+    retries: number2().int().nonnegative(),
+    crashRestarts: number2().int().nonnegative().optional(),
+    nextRunAt: exports_iso.datetime().optional(),
+    pauseReason: string2().max(32000).optional(),
+    failureKind: _enum([
+      "authentication",
+      "rate-limit",
+      "provider",
+      "environment",
+      "implementation",
+      "unknown-effect",
+      "budget",
+      "interrupted",
+      "chief-wait",
+      "chief-unavailable",
+      "integrity"
+    ]).optional(),
+    progressKey: string2().optional(),
+    interventionAt: exports_iso.datetime().optional(),
+    costReconciliations: array(strictObject({
+      runId: string2().min(1).max(2000),
+      costUsd: number2().finite().nonnegative(),
+      at: exports_iso.datetime(),
+      authority: literal("operator-recorded")
+    })).max(2000).optional()
+  });
+});
+
 // ../../packages/core/src/chief/execution.ts
 import { createHash } from "node:crypto";
 function chiefRecoveryStopped(mission) {
@@ -6785,8 +7090,15 @@ function executionState(mission) {
 }
 function finalizeAbandonedRuns(mission) {
   for (const run of mission.operations?.runs ?? []) {
+    if (run.executionState === "unknown")
+      continue;
     if (run.finishedAt)
       continue;
+    if (run.executionState === "running" && run.executionRecovery !== "local-process") {
+      markOperatingRunUnknown(run, "Coordinator ended before the runtime established a terminal outcome. Reconcile this execution before resuming.");
+      continue;
+    }
+    run.executionState = "settled";
     run.finishedAt = new Date().toISOString();
     run.elapsedMs = Math.max(0, Date.parse(run.finishedAt) - Date.parse(run.startedAt));
     run.outcome = "failed";
@@ -6796,7 +7108,37 @@ function finalizeAbandonedRuns(mission) {
     run.evidence = "Coordinator process ended before usage could be reconciled; cost remains unknown.";
   }
 }
+function assertNoUncertainExecution(mission) {
+  const run = mission.operations?.runs.find((entry) => entry.executionState === "unknown");
+  if (run)
+    throw new MissionPause(`Runtime execution ${run.runId} has an unknown outcome.${run.evidence ? ` Cause: ${run.evidence.slice(0, 1000)}.` : ""} Inspect and reconcile its saved execution record and any task effects before resuming; further Actor calls are stopped.`, "unknown-effect");
+}
+function reconcileExecution(mission, runId, evidence, authority = "operator-recorded") {
+  const run = mission.operations?.runs.find((entry) => entry.runId === runId);
+  const proof = evidence.trim();
+  if (run?.executionState !== "unknown" || !proof || proof.length > 2000)
+    throw new Error("Select an uncertain execution and record up to 2,000 characters of evidence that it stopped.");
+  if (authority === "local-process-guard" && run.executionRecovery !== "local-process")
+    throw new Error("A local process guard cannot reconcile a nonlocal execution. Obtain runtime termination proof.");
+  const at = new Date().toISOString();
+  run.executionState = "settled";
+  run.finishedAt = at;
+  const elapsed = Date.parse(at) - Date.parse(run.startedAt);
+  run.elapsedMs = Number.isFinite(elapsed) && elapsed >= 0 ? elapsed : null;
+  run.outcome = "failed";
+  run.evidence = proof;
+  const task = mission.tasks.find((entry) => entry.id === run.taskId);
+  if (task?.effectState === "running")
+    task.effectState = "unknown";
+  mission.history.push({
+    at,
+    stage: "execution-reconciled",
+    ...run.taskId ? { taskId: run.taskId } : {},
+    message: JSON.stringify({ runId, authority, evidence: proof })
+  });
+}
 function assertExecutionBudget(mission, now = Date.now()) {
+  assertNoUncertainExecution(mission);
   const policy = mission.executionPolicy;
   if (!policy)
     return;
@@ -6846,6 +7188,7 @@ function progressKey(mission, fingerprint) {
   })).digest("hex");
 }
 function pauseForFailure(mission, reason, taskId) {
+  assertNoUncertainExecution(mission);
   if (!mission.executionPolicy)
     return;
   const task = mission.plan?.tasks.find((entry) => entry.id === taskId);
@@ -6898,47 +7241,9 @@ function resolveExternalEffect(mission, taskId, result) {
     message: `Operator reconciled external effect: ${result}.`
   });
 }
-var executionPolicySchema, executionStateSchema, MissionPause;
+var MissionPause;
 var init_execution = __esm(() => {
-  init_zod();
-  executionPolicySchema = strictObject({
-    maxParallel: number2().int().min(1).max(8).default(3),
-    maxDurationSec: number2().int().min(1).max(604800).default(86400),
-    maxRuns: number2().int().min(1).max(2000).default(200),
-    maxEstimatedCostUsd: number2().finite().positive().optional(),
-    maxRetries: number2().int().min(0).max(10).default(3),
-    retryDelayMs: number2().int().min(10).max(300000).default(1000),
-    autoResume: boolean2().default(true)
-  });
-  executionStateSchema = strictObject({
-    startedAt: exports_iso.datetime(),
-    runsStarted: number2().int().nonnegative(),
-    retries: number2().int().nonnegative(),
-    crashRestarts: number2().int().nonnegative().optional(),
-    nextRunAt: exports_iso.datetime().optional(),
-    pauseReason: string2().max(32000).optional(),
-    failureKind: _enum([
-      "authentication",
-      "rate-limit",
-      "provider",
-      "environment",
-      "implementation",
-      "unknown-effect",
-      "budget",
-      "interrupted",
-      "chief-wait",
-      "chief-unavailable",
-      "integrity"
-    ]).optional(),
-    progressKey: string2().optional(),
-    interventionAt: exports_iso.datetime().optional(),
-    costReconciliations: array(strictObject({
-      runId: string2().min(1).max(2000),
-      costUsd: number2().finite().nonnegative(),
-      at: exports_iso.datetime(),
-      authority: literal("operator-recorded")
-    })).max(2000).optional()
-  });
+  init_contracts();
   MissionPause = class MissionPause extends Error {
     kind;
     nextRunAt;
@@ -6950,17 +7255,175 @@ var init_execution = __esm(() => {
   };
 });
 
+// ../../packages/core/src/chief/parallel-contract.ts
+var objectId, imageSchema, parallelBaselineSchema, parallelWorkspaceSchema, taskWorktreeRecordSchema, parallelDeliverySchema, ParallelIntegrationConflict;
+var init_parallel_contract = __esm(() => {
+  init_zod();
+  objectId = string2().regex(/^[a-f0-9]{40,64}$/);
+  imageSchema = strictObject({ mode: _enum(["100644", "100755", "120000"]), oid: objectId });
+  parallelBaselineSchema = strictObject({ head: objectId, tree: objectId });
+  parallelWorkspaceSchema = strictObject({
+    version: literal(1),
+    missionId: string2().min(1).max(200),
+    taskId: string2().min(1).max(200),
+    attempt: number2().int().min(1),
+    sourceWorkspacePath: string2().min(1),
+    path: string2().min(1),
+    branch: string2().min(1),
+    baselineHead: objectId,
+    baselineTree: objectId
+  });
+  taskWorktreeRecordSchema = parallelWorkspaceSchema;
+  parallelDeliverySchema = strictObject({
+    version: literal(1),
+    workspace: parallelWorkspaceSchema,
+    patchPath: string2().min(1),
+    patchSha256: string2().regex(/^[a-f0-9]{64}$/),
+    deliveryTree: objectId,
+    changes: array(strictObject({ path: string2().min(1), before: imageSchema.nullable(), after: imageSchema.nullable() })).max(20000),
+    status: _enum(["prepared", "applying", "applied"])
+  });
+  ParallelIntegrationConflict = class ParallelIntegrationConflict extends Error {
+    taskId;
+    paths;
+    constructor(taskId, paths, detail = "The shared worktree changed the same files.") {
+      super(`${detail} Task ${taskId}: ${paths.join(", ")}. Its isolated Actor edits were retained; inspect them before Chief recovery.`);
+      this.taskId = taskId;
+      this.paths = paths;
+    }
+  };
+});
+
+// ../../packages/core/src/chief/mission-state-schema.ts
+function refineChiefWaitSchedule(mission, ctx) {
+  if (mission.execution?.failureKind !== "chief-wait")
+    return;
+  const waiting = mission.supervision?.decisions.at(-1);
+  const at = Date.parse(waiting?.at ?? "");
+  if (waiting?.action !== "wait" || !waiting.retryAfterSec || !Number.isFinite(at) || mission.execution.nextRunAt !== new Date(at + waiting.retryAfterSec * 1000).toISOString())
+    ctx.addIssue({
+      code: "custom",
+      path: ["execution", "nextRunAt"],
+      message: "Saved Chief wait schedule does not match its decision. Restore the original wait checkpoint without resetting its budget."
+    });
+}
+var id, text, counter, reviewSchema, taskStateSchema, verificationSchema, advisoryReviewSchema, supervisionSchema;
+var init_mission_state_schema = __esm(() => {
+  init_zod();
+  init_parallel_contract();
+  id = string2().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/);
+  text = string2().trim().min(1).max(32000);
+  counter = number2().int().min(0);
+  reviewSchema = strictObject({
+    passed: boolean2(),
+    summary: text,
+    findings: array(text).max(50),
+    criteria: array(strictObject({ criterion: text, passed: boolean2(), evidence: text })).min(1).max(40).optional()
+  }).superRefine((review, ctx) => {
+    if (review.passed && review.findings.length > 0) {
+      ctx.addIssue({ code: "custom", message: "A passing review must have no unresolved findings." });
+    }
+    if (!review.passed && review.findings.length === 0) {
+      ctx.addIssue({ code: "custom", message: "A rejected review must include actionable findings." });
+    }
+  });
+  taskStateSchema = strictObject({
+    id,
+    reviewerId: id,
+    status: _enum(["pending", "running", "reviewing", "completed"]),
+    attempts: counter,
+    repairRound: counter.optional(),
+    output: string2().max(32000).optional(),
+    review: reviewSchema.optional(),
+    fingerprint: text.optional(),
+    effectState: _enum(["not-started", "running", "unknown", "completed"]).optional(),
+    parallel: taskWorktreeRecordSchema.optional()
+  });
+  verificationSchema = strictObject({
+    ok: boolean2(),
+    output: string2().max(32000).optional(),
+    fingerprint: text
+  });
+  advisoryReviewSchema = strictObject({
+    planKey: text,
+    reviewerId: id,
+    fingerprint: text,
+    review: reviewSchema
+  });
+  supervisionSchema = strictObject({
+    maxRounds: number2().int().min(1).max(50),
+    rounds: counter,
+    stalledRounds: counter,
+    lastFingerprint: text.optional(),
+    originalAcceptance: array(text).min(1).max(240).optional(),
+    operatorGoal: text.optional(),
+    operatorVerifyCommand: string2().trim().max(32000).optional(),
+    pendingRecovery: strictObject({ reason: text, taskId: id.optional() }).optional(),
+    decisions: array(strictObject({
+      round: number2().int().min(1).max(50),
+      at: text,
+      action: _enum(["repair", "reassign", "replan", "stop", "wait"]),
+      retryAfterSec: number2().int().min(1).max(86400).optional(),
+      reason: text,
+      fingerprint: text,
+      taskId: id.optional(),
+      personaId: id.optional(),
+      instructions: text.optional(),
+      previousTasks: array(taskStateSchema).max(12).optional(),
+      evidence: strictObject({ finalReview: reviewSchema.optional(), verification: verificationSchema.optional() }).optional()
+    }).superRefine((decision, ctx) => {
+      if (decision.action === "wait" !== (decision.retryAfterSec !== undefined))
+        ctx.addIssue({
+          code: "custom",
+          path: ["retryAfterSec"],
+          message: "Only a Chief wait decision must carry a bounded retry delay."
+        });
+      if (decision.action === "wait" && !exports_iso.datetime().safeParse(decision.at).success)
+        ctx.addIssue({
+          code: "custom",
+          path: ["at"],
+          message: "Chief wait decisions require their original ISO timestamp."
+        });
+    })).max(50)
+  });
+});
+
+// ../../packages/core/src/chief/review-gates.ts
+var id2, text2, reviewGateSchema, reviewGatesSchema, gateReviewSchema;
+var init_review_gates = __esm(() => {
+  init_zod();
+  init_mission_state_schema();
+  id2 = string2().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/, "Use 1–64 letters, numbers, underscores or hyphens, starting with a letter or number.");
+  text2 = string2().trim().min(1).max(32000);
+  reviewGateSchema = strictObject({ id: id2, instructions: text2 });
+  reviewGatesSchema = array(reviewGateSchema).max(8).superRefine((gates, ctx) => {
+    if (new Set(gates.map((gate) => gate.id)).size !== gates.length)
+      ctx.addIssue({
+        code: "custom",
+        message: "Chief review gate IDs must be unique. Set distinct chief.review_gates[].id values."
+      });
+  });
+  gateReviewSchema = strictObject({
+    gateId: id2,
+    taskId: id2,
+    reviewerId: id2,
+    fingerprint: text2,
+    review: reviewSchema
+  });
+});
+
 // ../../packages/core/src/chief/operations.ts
-var actorType, text, amount, routingCandidateSchema, chiefOperatingPolicySchema, operatingRunSchema, routeEvidenceSchema, reviewDecisionSchema, chiefOperationsSchema;
+var actorType, text3, amount, routingCandidateSchema, chiefOperatingPolicySchema, operatingRunSchema, routeEvidenceSchema, reviewDecisionSchema, chiefOperationsSchema;
 var init_operations = __esm(() => {
   init_zod();
   init_skill_matrix_schema();
+  init_review_gates();
   actorType = string2().regex(/^[a-z0-9][a-z0-9-]{0,127}$/);
-  text = string2().trim().min(1).max(2000);
+  text3 = string2().trim().min(1).max(2000);
   amount = number2().finite().nonnegative();
   routingCandidateSchema = strictObject({
     actorType,
-    model: text.optional(),
+    model: text3.optional(),
     inputPerMillionUsd: amount.optional(),
     outputPerMillionUsd: amount.optional()
   });
@@ -6971,19 +7434,20 @@ var init_operations = __esm(() => {
       minSuccessRate: number2().min(0).max(1)
     }).optional(),
     reviewVendor: _enum(["prefer", "require", "off"]),
+    reviewGates: reviewGatesSchema.optional(),
     readyActors: array(actorType).max(20).optional(),
     memory: boolean2(),
     skillCompatibility: skillCompatibilityPolicySchema.optional(),
     metricTargets: array(strictObject({
-      name: text,
-      unit: text.optional(),
+      name: text3,
+      unit: text3.optional(),
       direction: _enum(["increase", "decrease"]),
       target: number2().finite().optional()
     })).max(20).optional()
   });
   operatingRunSchema = strictObject({
-    runId: text,
-    taskId: text.optional(),
+    runId: text3,
+    taskId: text3.optional(),
     stage: _enum([
       "plan",
       "technical-review",
@@ -6991,42 +7455,46 @@ var init_operations = __esm(() => {
       "marketing-review",
       "work",
       "review",
+      "gate-review",
       "final-review",
       "supervise",
       "report"
     ]),
-    actorId: text,
+    actorId: text3,
     actorType,
-    model: text.optional(),
-    actualModel: text.optional(),
-    startedAt: text,
-    finishedAt: text.nullable(),
+    model: text3.optional(),
+    actualModel: text3.optional(),
+    startedAt: text3,
+    finishedAt: text3.nullable(),
     elapsedMs: amount.nullable(),
     inputTokens: number2().int().nonnegative().nullable(),
     outputTokens: number2().int().nonnegative().nullable(),
     costUsd: amount.nullable(),
     outcome: _enum(["pending", "passed", "rejected", "failed"]),
-    routingReason: text.optional(),
-    evidence: text.optional(),
-    fingerprint: text.optional()
+    executionState: _enum(["running", "settled", "unknown"]).optional(),
+    executionRecovery: _enum(["local-process", "reconcile"]).optional(),
+    routingReason: text3.optional(),
+    evidence: text3.optional(),
+    fingerprint: text3.optional()
   });
   routeEvidenceSchema = strictObject({
     actorType,
-    model: text.optional(),
+    model: text3.optional(),
     samples: number2().int().nonnegative(),
     successes: number2().int().nonnegative(),
     totalCostUsd: amount.nullable(),
     successfulDeliverableCostUsd: amount.nullable()
   }).refine((entry) => entry.successes <= entry.samples, "Route successes cannot exceed actual samples.");
   reviewDecisionSchema = strictObject({
-    taskId: text,
-    runId: text.optional(),
+    taskId: text3,
+    gateId: text3.optional(),
+    runId: text3.optional(),
     workerActorType: actorType,
-    reviewerId: text,
+    reviewerId: text3,
     reviewerActorType: actorType,
     crossVendor: boolean2(),
     outcome: _enum(["assigned", "passed", "rejected", "failed"]).optional(),
-    reason: text
+    reason: text3
   });
   chiefOperationsSchema = strictObject({
     runs: array(operatingRunSchema).max(20000),
@@ -7036,55 +7504,55 @@ var init_operations = __esm(() => {
 });
 
 // ../../packages/core/src/chief/organization-types.ts
-var text2 = (maximum) => string2().trim().min(1).max(maximum), organizationTimestampSchema, metricTargetSchema, memoryEvidenceSchema, organizationMemoryInputSchema, organizationMemorySchema, businessMetricInputSchema, metricMeasurementWindowSchema, collectedBusinessMetricInputSchema, businessMetricSampleSchema, metricComparisonSchema, businessExperimentInputSchema, businessExperimentSchema, organizationOutcomeSchema, organizationContextSchema;
+var text4 = (maximum) => string2().trim().min(1).max(maximum), organizationTimestampSchema, metricTargetSchema, memoryEvidenceSchema, organizationMemoryInputSchema, organizationMemorySchema, businessMetricInputSchema, metricMeasurementWindowSchema, collectedBusinessMetricInputSchema, businessMetricSampleSchema, metricComparisonSchema, businessExperimentInputSchema, businessExperimentSchema, organizationOutcomeSchema, organizationContextSchema;
 var init_organization_types = __esm(() => {
   init_zod();
   init_operations();
   organizationTimestampSchema = exports_iso.datetime({ offset: true });
   metricTargetSchema = strictObject({
-    name: text2(120),
-    unit: text2(80).optional(),
+    name: text4(120),
+    unit: text4(80).optional(),
     direction: _enum(["increase", "decrease"]),
     target: number2().finite().optional()
   });
   memoryEvidenceSchema = strictObject({
-    path: text2(2000),
+    path: text4(2000),
     sha256: string2().regex(/^[a-f0-9]{64}$/),
-    verification: text2(1000).optional()
+    verification: text4(1000).optional()
   });
   organizationMemoryInputSchema = strictObject({
-    id: text2(120).optional(),
+    id: text4(120).optional(),
     kind: _enum(["lesson", "decision", "stack-standard"]),
-    content: text2(2000),
-    source: text2(500).default("Operator via av memory add"),
-    tags: array(text2(80)).max(20).default([]),
+    content: text4(2000),
+    source: text4(500).default("Operator via av memory add"),
+    tags: array(text4(80)).max(20).default([]),
     evidence: array(memoryEvidenceSchema).max(20).default([])
   });
   organizationMemorySchema = organizationMemoryInputSchema.extend({
-    id: text2(120),
+    id: text4(120),
     approval: literal("human-approved"),
     createdAt: organizationTimestampSchema
   });
   businessMetricInputSchema = strictObject({
-    id: text2(120).optional(),
-    name: text2(120),
+    id: text4(120).optional(),
+    name: text4(120),
     value: number2().finite(),
-    unit: text2(80),
-    source: text2(500),
+    unit: text4(80),
+    source: text4(500),
     timestamp: organizationTimestampSchema,
     provenance: literal("operator-recorded").optional(),
-    experimentId: text2(120).optional()
+    experimentId: text4(120).optional()
   });
   metricMeasurementWindowSchema = strictObject({ start: organizationTimestampSchema, end: organizationTimestampSchema }).refine((window) => Date.parse(window.start) < Date.parse(window.end), "Measurement window must end after it starts.");
   collectedBusinessMetricInputSchema = businessMetricInputSchema.omit({ provenance: true }).extend({
-    sourceId: text2(120),
+    sourceId: text4(120),
     collectedAt: organizationTimestampSchema,
     window: metricMeasurementWindowSchema.optional()
   });
   businessMetricSampleSchema = businessMetricInputSchema.extend({
-    id: text2(120),
+    id: text4(120),
     provenance: _enum(["operator-recorded", "source-collected"]),
-    sourceId: text2(120).optional(),
+    sourceId: text4(120).optional(),
     collectedAt: organizationTimestampSchema.optional(),
     window: metricMeasurementWindowSchema.optional()
   }).superRefine((sample, ctx) => {
@@ -7108,8 +7576,8 @@ var init_organization_types = __esm(() => {
       });
   });
   metricComparisonSchema = strictObject({
-    name: text2(120),
-    unit: text2(80).optional(),
+    name: text4(120),
+    unit: text4(80).optional(),
     direction: _enum(["increase", "decrease"]),
     target: number2().finite().optional(),
     status: _enum(["improved", "regressed", "unchanged", "missing-evidence", "unit-mismatch"]),
@@ -7117,58 +7585,58 @@ var init_organization_types = __esm(() => {
     current: businessMetricSampleSchema.optional(),
     delta: number2().finite().optional(),
     targetMet: boolean2().optional(),
-    reason: text2(500)
+    reason: text4(500)
   });
   businessExperimentInputSchema = strictObject({
-    id: text2(120),
-    name: text2(200),
-    hypothesis: text2(1000),
+    id: text4(120),
+    name: text4(200),
+    hypothesis: text4(1000),
     targets: array(metricTargetSchema).min(1).max(20),
-    beforeSampleIds: array(text2(120)).max(100),
-    afterSampleIds: array(text2(120)).max(100),
+    beforeSampleIds: array(text4(120)).max(100),
+    afterSampleIds: array(text4(120)).max(100),
     timestamp: organizationTimestampSchema,
     adjudication: strictObject({
       status: _enum(["supported", "contradicted", "inconclusive"]),
-      reason: text2(1000),
-      source: text2(500),
+      reason: text4(1000),
+      source: text4(500),
       timestamp: organizationTimestampSchema
     }).optional()
   });
   businessExperimentSchema = businessExperimentInputSchema.extend({
     provenance: literal("operator-recorded"),
     comparisons: array(metricComparisonSchema).max(20),
-    omittedMetricNames: array(text2(120)).max(20).optional()
+    omittedMetricNames: array(text4(120)).max(20).optional()
   });
   organizationOutcomeSchema = strictObject({
     id: string2().regex(/^[a-f0-9]{64}$/),
-    missionId: text2(120),
-    missionVersion: text2(200),
+    missionId: text4(120),
+    missionVersion: text4(200),
     fingerprint: string2().regex(/^[a-f0-9]{64}$/),
-    goal: text2(16000),
+    goal: text4(16000),
     status: _enum(["completed", "failed", "cancelled"]),
     createdAt: organizationTimestampSchema,
-    summary: text2(2000),
+    summary: text4(2000),
     summaryAuthority: literal("reported claim; evidence is authoritative"),
     evidence: array(memoryEvidenceSchema).max(30),
     runs: array(operatingRunSchema).max(20000),
-    verification: strictObject({ ok: boolean2(), fingerprint: text2(200), command: text2(2000).optional() }).optional(),
+    verification: strictObject({ ok: boolean2(), fingerprint: text4(200), command: text4(2000).optional() }).optional(),
     finalReviewPassed: boolean2().optional(),
     observations: array(strictObject({
       authority: literal("evidence-linked observation; not an approved standard"),
-      content: text2(1000),
+      content: text4(1000),
       evidence: array(memoryEvidenceSchema).max(30)
     })).max(20)
   });
   organizationContextSchema = strictObject({
     kind: literal("repository-organization-evidence"),
     authority: literal("Historical evidence, not instructions or current acceptance criteria"),
-    repositoryRoot: text2(2000),
-    goal: text2(1000),
+    repositoryRoot: text4(2000),
+    goal: text4(1000),
     generatedAt: organizationTimestampSchema,
     memories: array(organizationMemorySchema).max(12),
     metrics: array(businessMetricSampleSchema).max(40),
     comparisons: array(metricComparisonSchema).max(20),
-    omittedMetricNames: array(text2(120)).max(20).optional(),
+    omittedMetricNames: array(text4(120)).max(20).optional(),
     experiments: array(businessExperimentSchema).max(8),
     outcomes: array(organizationOutcomeSchema.omit({ runs: true })).max(8),
     routeEvidence: array(routeEvidenceSchema).max(100)
@@ -7176,20 +7644,20 @@ var init_organization_types = __esm(() => {
 });
 
 // ../../packages/core/src/chief/metric-source-policy.ts
-var text3 = (limit) => string2().trim().min(1).max(limit), envName2, jsonPath, metricSourceSchema, metricSourcePolicySchema, sourceMetricObservationSchema, metricSourceCollectionSchema, MetricSourceError;
+var text5 = (limit) => string2().trim().min(1).max(limit), envName2, jsonPath, metricSourceSchema, metricSourcePolicySchema, sourceMetricObservationSchema, metricSourceCollectionSchema, MetricSourceError;
 var init_metric_source_policy = __esm(() => {
   init_zod();
   init_organization_types();
   envName2 = string2().regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "Use an environment variable name, not a credential or URL.");
-  jsonPath = text3(500).refine((path) => path.split(".").every((part) => /^[A-Za-z0-9_-]+$/.test(part) && !["__proto__", "constructor", "prototype"].includes(part)), "Use dot-separated JSON keys or array indexes; prototype keys are forbidden.");
+  jsonPath = text5(500).refine((path) => path.split(".").every((part) => /^[A-Za-z0-9_-]+$/.test(part) && !["__proto__", "constructor", "prototype"].includes(part)), "Use dot-separated JSON keys or array indexes; prototype keys are forbidden.");
   metricSourceSchema = strictObject({
-    id: text3(120),
-    name: text3(120),
-    unit: text3(80),
-    adapter: text3(80).default("http-json"),
+    id: text5(120),
+    name: text5(120),
+    unit: text5(80),
+    adapter: text5(80).default("http-json"),
     url_env: envName2.optional(),
     token_env: envName2.optional(),
-    file: text3(2000).optional(),
+    file: text5(2000).optional(),
     value_path: jsonPath.default("value"),
     timestamp_path: jsonPath.default("timestamp"),
     unit_path: jsonPath.default("unit"),
@@ -7233,7 +7701,7 @@ var init_metric_source_policy = __esm(() => {
   });
   sourceMetricObservationSchema = strictObject({
     value: number2().finite(),
-    unit: text3(80),
+    unit: text5(80),
     timestamp: organizationTimestampSchema,
     window: metricMeasurementWindowSchema.optional()
   });
@@ -7241,11 +7709,11 @@ var init_metric_source_policy = __esm(() => {
     collectedAt: organizationTimestampSchema,
     nextPollAt: organizationTimestampSchema,
     results: array(strictObject({
-      sourceId: text3(120),
-      name: text3(120),
+      sourceId: text5(120),
+      name: text5(120),
       status: _enum(["collected", "unchanged", "unavailable", "failed"]),
       sample: businessMetricSampleSchema.optional(),
-      reason: text3(1000).optional()
+      reason: text5(1000).optional()
     })).max(20)
   });
   MetricSourceError = class MetricSourceError extends Error {
@@ -7305,6 +7773,7 @@ function chiefOperatingPolicy(config, readyActors, automatic = true, skillCompat
       minSuccessRate: config.routing.min_success_rate
     } : automatic && readyActors.length > 1 ? { candidates: readyActors.map((actorType) => ({ actorType })), minSamples: 3, minSuccessRate: 0.8 } : undefined,
     reviewVendor: config.review_vendor ?? "prefer",
+    reviewGates: config.review_gates,
     memory: config.memory ?? true,
     metricTargets: config.metric_targets,
     readyActors,
@@ -7335,6 +7804,7 @@ var init_chief_schema = __esm(() => {
   init_operations();
   init_organization_types();
   init_report_delivery_contract();
+  init_review_gates();
   init_tool_environment();
   price = number2().finite().nonnegative().optional();
   chiefConfigSchema = strictObject({
@@ -7361,6 +7831,7 @@ var init_chief_schema = __esm(() => {
       min_success_rate: number2().min(0).max(1).default(0.8)
     }).optional(),
     review_vendor: _enum(["prefer", "require", "off"]).optional(),
+    review_gates: reviewGatesSchema.optional(),
     memory: boolean2().optional(),
     metric_targets: array(metricTargetSchema).max(20).optional(),
     reporting: reportDeliveryPolicySchema.optional(),
@@ -7448,6 +7919,67 @@ function resolveProjectConfigPath(root) {
 var PROJECT_CONFIG_FILENAME = "av.yaml";
 var init_project_config_path = () => {};
 
+// ../../packages/core/src/config/team-schema.ts
+function normalizeTeamRelayUrl(value) {
+  const input = value.trim();
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new Error("Set team.relay_url to an absolute HTTPS URL (HTTP is allowed only on loopback).");
+  }
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if ([...input].some((character) => character.charCodeAt(0) <= 32 || character.charCodeAt(0) === 127) || url.protocol !== "https:" && !(url.protocol === "http:" && loopback) || url.username || url.password || input.includes("?") || input.includes("#")) {
+    throw new Error("Set team.relay_url to HTTPS or loopback HTTP, without credentials, a query or a fragment.");
+  }
+  return url.href.replace(/\/+$/, "");
+}
+function assertTeamConfigMigrated(raw, path) {
+  const team = raw.team;
+  if (typeof team !== "object" || team === null)
+    return;
+  const keys = ["supabase_url", "supabase_anon_key"].filter((key) => Object.hasOwn(team, key));
+  if (keys.length)
+    throw new TeamConfigMigrationError(keys, path);
+}
+var teamRelayUrlSchema, legacyTeamMigration, teamConfigSchema, TeamConfigMigrationError;
+var init_team_schema = __esm(() => {
+  init_zod();
+  teamRelayUrlSchema = string2().transform((value, context) => {
+    try {
+      return normalizeTeamRelayUrl(value);
+    } catch (error) {
+      context.addIssue({ code: "custom", message: error.message });
+      return NEVER;
+    }
+  });
+  legacyTeamMigration = "is no longer supported. Remove this key from av.yaml or ~/.config/agent-valley/settings.yaml; " + "set team.relay_url and team.id for clients, and team.turso_url plus team.turso_auth_token_env on the central server. " + "Keep the Turso database token on the server and run 'av login' with a user team token.";
+  teamConfigSchema = object({
+    relay_url: teamRelayUrlSchema.optional(),
+    turso_url: string2().trim().min(1).optional(),
+    turso_auth_token_env: string2().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).optional(),
+    id: uuid2({
+      error: "Set team.id in av.yaml or ~/.config/agent-valley/settings.yaml to the team UUID supplied by your administrator."
+    }).optional(),
+    display_name: string2().min(1).optional(),
+    supabase_url: unknown().optional(),
+    supabase_anon_key: unknown().optional()
+  }).strict().superRefine((team, context) => {
+    for (const key of ["supabase_url", "supabase_anon_key"]) {
+      if (Object.hasOwn(team, key))
+        context.addIssue({ code: "custom", path: [key], message: `team.${key} ${legacyTeamMigration}` });
+    }
+  }).transform(({ supabase_url: _url, supabase_anon_key: _key, ...team }) => team);
+  TeamConfigMigrationError = class TeamConfigMigrationError extends Error {
+    constructor(keys, path) {
+      super(`Team config migration required (${path}):
+${keys.map((key) => `  - team.${key} ${legacyTeamMigration}`).join(`
+`)}`);
+      this.name = "TeamConfigMigrationError";
+    }
+  };
+});
+
 // ../../packages/core/src/config/tunnel-schema.ts
 function buildTunnelConfig(project) {
   const tunnel = project?.tunnel;
@@ -14540,6 +15072,7 @@ function loadGlobalConfig(configPath) {
   const raw = readYamlFile(path);
   if (!raw)
     return null;
+  assertTeamConfigMigrated(raw, path);
   const result = globalConfigSchema.safeParse(raw);
   if (!result.success) {
     const issues = result.error.issues.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join(`
@@ -14555,6 +15088,7 @@ function loadProjectConfig(projectRoot) {
   const raw = readYamlFile(path);
   if (!raw)
     return null;
+  assertTeamConfigMigrated(raw, path);
   const result = projectConfigSchema.safeParse(raw);
   if (!result.success) {
     const issues = result.error.issues.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join(`
@@ -14585,21 +15119,24 @@ function mergeConfigs(global, project, env) {
       trackerKind = "github";
   }
   let githubMerged;
+  let githubWorkflowStates = null;
   if (trackerKind === "github" && project?.github) {
     const envName = project.github.token_env ?? "GITHUB_TOKEN";
     const token = env[envName] ?? "";
+    const labels = {
+      todo: project.github.labels?.todo ?? "",
+      inProgress: project.github.labels?.in_progress ?? "",
+      done: project.github.labels?.done ?? "",
+      cancelled: project.github.labels?.cancelled ?? ""
+    };
     githubMerged = {
       token,
       owner: project.github.owner ?? "",
       repo: project.github.repo ?? "",
       webhookSecret: project.github.webhook_secret ?? "",
-      labels: {
-        todo: project.github.labels?.todo ?? "",
-        inProgress: project.github.labels?.in_progress ?? "",
-        done: project.github.labels?.done ?? "",
-        cancelled: project.github.labels?.cancelled ?? ""
-      }
+      labels
     };
+    githubWorkflowStates = labels;
   }
   return {
     trackerKind,
@@ -14607,7 +15144,7 @@ function mergeConfigs(global, project, env) {
     linearTeamId: project?.linear?.team_id ?? "",
     linearTeamUuid: project?.linear?.team_uuid ?? "",
     linearWebhookSecret: project?.linear?.webhook_secret ?? "",
-    workflowStates: {
+    workflowStates: githubWorkflowStates ?? {
       todo: project?.linear?.workflow_states?.todo ?? "",
       inProgress: project?.linear?.workflow_states?.in_progress ?? "",
       done: project?.linear?.workflow_states?.done ?? "",
@@ -14635,8 +15172,9 @@ function mergeConfigs(global, project, env) {
     })),
     scoringModel: project?.scoring?.model ?? undefined,
     scoreRouting: project?.scoring?.routes ?? undefined,
-    supabaseUrl: project?.team?.supabase_url ?? global?.team?.supabase_url ?? undefined,
-    supabaseAnonKey: project?.team?.supabase_anon_key ?? global?.team?.supabase_anon_key ?? undefined,
+    teamRelayUrl: project?.team?.relay_url ?? global?.team?.relay_url ?? undefined,
+    tursoUrl: project?.team?.turso_url ?? global?.team?.turso_url ?? undefined,
+    tursoAuthTokenEnv: project?.team?.turso_auth_token_env ?? global?.team?.turso_auth_token_env ?? "TURSO_AUTH_TOKEN",
     teamId: project?.team?.id ?? global?.team?.id ?? undefined,
     displayName: project?.team?.display_name ?? global?.team?.display_name ?? undefined,
     observability: buildObservabilityConfig(project),
@@ -14690,6 +15228,7 @@ var init_yaml_loader = __esm(() => {
   init_observability_schema();
   init_project_config_path();
   init_task_schema();
+  init_team_schema();
   init_tunnel_schema();
   init_verify_schema();
   init_yaml_file();
@@ -14707,12 +15246,7 @@ var init_yaml_loader = __esm(() => {
     server: object({
       port: number2().int().min(1).max(65535).optional()
     }).optional(),
-    team: object({
-      supabase_url: string2().optional(),
-      supabase_anon_key: string2().optional(),
-      id: string2().optional(),
-      display_name: string2().optional()
-    }).optional()
+    team: teamConfigSchema.optional()
   }).strict().overwrite(normalizeActorDefaults);
   projectConfigSchema = object({
     tracker: object({
@@ -14765,12 +15299,7 @@ var init_yaml_loader = __esm(() => {
       model: string2().optional(),
       routes: scoreRoutingSchema.optional()
     }).optional(),
-    team: object({
-      supabase_url: string2().optional(),
-      supabase_anon_key: string2().optional(),
-      id: string2().optional(),
-      display_name: string2().optional()
-    }).optional(),
+    team: teamConfigSchema.optional(),
     observability: observabilityProjectSchema,
     budget: budgetProjectSchema,
     tunnel: tunnelProjectSchema,
@@ -14836,9 +15365,12 @@ var init_yaml_loader = __esm(() => {
     })),
     scoringModel: string2().optional(),
     scoreRouting: scoreRoutingSchema.optional(),
-    supabaseUrl: string2().optional(),
-    supabaseAnonKey: string2().optional(),
-    teamId: string2().optional(),
+    teamRelayUrl: teamRelayUrlSchema.optional(),
+    tursoUrl: string2().min(1).optional(),
+    tursoAuthTokenEnv: string2().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).optional(),
+    teamId: uuid2({
+      error: "Set team.id in av.yaml or ~/.config/agent-valley/settings.yaml to the team UUID supplied by your administrator."
+    }).optional(),
     displayName: string2().optional(),
     observability: observabilityMergedSchema,
     budget: budgetMergedSchema,
@@ -15038,127 +15570,6 @@ var init_types = __esm(() => {
   });
 });
 
-// ../../packages/core/src/tracker/linear-webhook-client.ts
-function isPermissionErrorMessage(message) {
-  return /permission|forbidden|not authorized|unauthorized|scope/i.test(message);
-}
-function webhookPermissionError(action, cause) {
-  return new Error(`Linear API key lacks permission to ${action} webhooks.
-` + "  Fix: regenerate your Linear API key at https://linear.app/settings/api with webhook create/manage " + "scope, update LINEAR_API_KEY, then re-run `av up`.\n" + `  Underlying error: ${cause}`);
-}
-async function findExistingWebhook(apiKey, teamId, url, label) {
-  try {
-    const data = await linearGraphQL(apiKey, LIST_WEBHOOKS_QUERY, { teamId });
-    const parsed = listWebhooksDataSchema.safeParse(data);
-    if (!parsed.success) {
-      throw new Error(`Linear webhooks response validation failed: ${parsed.error.message}`);
-    }
-    const nodes = parsed.data.webhooks?.nodes ?? [];
-    return nodes.find((w) => w.label === label) ?? nodes.find((w) => w.url === url);
-  } catch (err) {
-    const msg = err.message;
-    if (isPermissionErrorMessage(msg))
-      throw webhookPermissionError("list", msg);
-    throw err;
-  }
-}
-async function upsertWebhook(params) {
-  const label = params.label ?? WEBHOOK_LABEL;
-  const existing = await findExistingWebhook(params.apiKey, params.teamId, params.url, label);
-  if (existing) {
-    try {
-      const data = await linearGraphQL(params.apiKey, UPDATE_WEBHOOK_MUTATION, {
-        id: existing.id,
-        url: params.url,
-        enabled: true
-      });
-      const parsed = webhookUpdateDataSchema.safeParse(data);
-      const webhook = parsed.success ? parsed.data.webhookUpdate?.webhook : undefined;
-      if (!parsed.success || !parsed.data.webhookUpdate?.success || !webhook) {
-        throw new Error(`Failed to update Linear webhook: id=${existing.id}, url=${params.url}
-` + "  Fix: verify LINEAR_API_KEY still has webhook manage permission for this team.");
-      }
-      logger.info("tracker-client", "Updated Linear webhook", { teamId: params.teamId, webhookId: webhook.id });
-      return webhook;
-    } catch (err) {
-      const msg = err.message;
-      if (isPermissionErrorMessage(msg))
-        throw webhookPermissionError("update", msg);
-      throw err;
-    }
-  }
-  try {
-    const data = await linearGraphQL(params.apiKey, CREATE_WEBHOOK_MUTATION, {
-      teamId: params.teamId,
-      url: params.url,
-      secret: params.secret,
-      label
-    });
-    const parsed = webhookCreateDataSchema.safeParse(data);
-    const webhook = parsed.success ? parsed.data.webhookCreate?.webhook : undefined;
-    if (!parsed.success || !parsed.data.webhookCreate?.success || !webhook) {
-      throw new Error(`Failed to create Linear webhook: teamId=${params.teamId}, url=${params.url}
-` + "  Fix: verify LINEAR_API_KEY has webhook create permission for this team. Regenerate at " + "https://linear.app/settings/api if needed.");
-    }
-    logger.info("tracker-client", "Created Linear webhook", { teamId: params.teamId, webhookId: webhook.id });
-    return webhook;
-  } catch (err) {
-    const msg = err.message;
-    if (isPermissionErrorMessage(msg))
-      throw webhookPermissionError("create", msg);
-    throw err;
-  }
-}
-var WEBHOOK_LABEL = "agent-valley", webhookNodeSchema, listWebhooksDataSchema, webhookCreateDataSchema, webhookUpdateDataSchema, LIST_WEBHOOKS_QUERY = `
-query ListWebhooks($teamId: String!) {
-  webhooks(filter: { team: { id: { eq: $teamId } } }) {
-    nodes { id url label enabled }
-  }
-}
-`, CREATE_WEBHOOK_MUTATION = `
-mutation CreateWebhook($teamId: String!, $url: String!, $secret: String!, $label: String!) {
-  webhookCreate(input: { teamId: $teamId, url: $url, secret: $secret, label: $label, resourceTypes: ["Issue"], enabled: true }) {
-    success
-    webhook { id url label enabled }
-  }
-}
-`, UPDATE_WEBHOOK_MUTATION = `
-mutation UpdateWebhook($id: String!, $url: String!, $enabled: Boolean!) {
-  webhookUpdate(id: $id, input: { url: $url, enabled: $enabled }) {
-    success
-    webhook { id url label enabled }
-  }
-}
-`;
-var init_linear_webhook_client = __esm(() => {
-  init_zod();
-  init_logger();
-  init_linear_client();
-  webhookNodeSchema = object({
-    id: string2(),
-    url: string2(),
-    label: string2().nullable().optional(),
-    enabled: boolean2()
-  });
-  listWebhooksDataSchema = object({
-    webhooks: object({
-      nodes: array(webhookNodeSchema)
-    }).optional()
-  });
-  webhookCreateDataSchema = object({
-    webhookCreate: object({
-      success: boolean2(),
-      webhook: webhookNodeSchema.optional()
-    }).optional()
-  });
-  webhookUpdateDataSchema = object({
-    webhookUpdate: object({
-      success: boolean2(),
-      webhook: webhookNodeSchema.optional()
-    }).optional()
-  });
-});
-
 // ../../packages/core/src/tracker/linear-client.ts
 import { request as httpsRequest } from "node:https";
 function postGraphQLWithNodeHttps(apiKey, query, variables) {
@@ -15317,7 +15728,6 @@ var init_linear_client = __esm(() => {
   init_logger();
   init_linear_issue_mapper();
   init_types();
-  init_linear_webhook_client();
   ISSUES_BY_STATE_QUERY = `
 query GetIssuesByState($teamId: String!, $stateIds: [ID!]!, $cursor: String) {
   team(id: $teamId) {
@@ -15341,6 +15751,127 @@ query GetIssuesByState($teamId: String!, $stateIds: [ID!]!, $cursor: String) {
 `;
 });
 
+// ../../packages/core/src/tracker/linear-webhook-client.ts
+function isPermissionErrorMessage(message) {
+  return /permission|forbidden|not authorized|unauthorized|scope/i.test(message);
+}
+function webhookPermissionError(action, cause) {
+  return new Error(`Linear API key lacks permission to ${action} webhooks.
+` + "  Fix: regenerate your Linear API key at https://linear.app/settings/api with webhook create/manage " + "scope, update LINEAR_API_KEY, then re-run `av up`.\n" + `  Underlying error: ${cause}`);
+}
+async function findExistingWebhook(apiKey, teamId, url, label) {
+  try {
+    const data = await linearGraphQL(apiKey, LIST_WEBHOOKS_QUERY, { teamId });
+    const parsed = listWebhooksDataSchema.safeParse(data);
+    if (!parsed.success) {
+      throw new Error(`Linear webhooks response validation failed: ${parsed.error.message}`);
+    }
+    const nodes = parsed.data.webhooks?.nodes ?? [];
+    return nodes.find((w) => w.label === label) ?? nodes.find((w) => w.url === url);
+  } catch (err) {
+    const msg = err.message;
+    if (isPermissionErrorMessage(msg))
+      throw webhookPermissionError("list", msg);
+    throw err;
+  }
+}
+async function upsertWebhook(params) {
+  const label = params.label ?? WEBHOOK_LABEL;
+  const existing = await findExistingWebhook(params.apiKey, params.teamId, params.url, label);
+  if (existing) {
+    try {
+      const data = await linearGraphQL(params.apiKey, UPDATE_WEBHOOK_MUTATION, {
+        id: existing.id,
+        url: params.url,
+        enabled: true
+      });
+      const parsed = webhookUpdateDataSchema.safeParse(data);
+      const webhook = parsed.success ? parsed.data.webhookUpdate?.webhook : undefined;
+      if (!parsed.success || !parsed.data.webhookUpdate?.success || !webhook) {
+        throw new Error(`Failed to update Linear webhook: id=${existing.id}, url=${params.url}
+` + "  Fix: verify LINEAR_API_KEY still has webhook manage permission for this team.");
+      }
+      logger.info("tracker-client", "Updated Linear webhook", { teamId: params.teamId, webhookId: webhook.id });
+      return webhook;
+    } catch (err) {
+      const msg = err.message;
+      if (isPermissionErrorMessage(msg))
+        throw webhookPermissionError("update", msg);
+      throw err;
+    }
+  }
+  try {
+    const data = await linearGraphQL(params.apiKey, CREATE_WEBHOOK_MUTATION, {
+      teamId: params.teamId,
+      url: params.url,
+      secret: params.secret,
+      label
+    });
+    const parsed = webhookCreateDataSchema.safeParse(data);
+    const webhook = parsed.success ? parsed.data.webhookCreate?.webhook : undefined;
+    if (!parsed.success || !parsed.data.webhookCreate?.success || !webhook) {
+      throw new Error(`Failed to create Linear webhook: teamId=${params.teamId}, url=${params.url}
+` + "  Fix: verify LINEAR_API_KEY has webhook create permission for this team. Regenerate at " + "https://linear.app/settings/api if needed.");
+    }
+    logger.info("tracker-client", "Created Linear webhook", { teamId: params.teamId, webhookId: webhook.id });
+    return webhook;
+  } catch (err) {
+    const msg = err.message;
+    if (isPermissionErrorMessage(msg))
+      throw webhookPermissionError("create", msg);
+    throw err;
+  }
+}
+var WEBHOOK_LABEL = "agent-valley", webhookNodeSchema, listWebhooksDataSchema, webhookCreateDataSchema, webhookUpdateDataSchema, LIST_WEBHOOKS_QUERY = `
+query ListWebhooks($teamId: String!) {
+  webhooks(filter: { team: { id: { eq: $teamId } } }) {
+    nodes { id url label enabled }
+  }
+}
+`, CREATE_WEBHOOK_MUTATION = `
+mutation CreateWebhook($teamId: String!, $url: String!, $secret: String!, $label: String!) {
+  webhookCreate(input: { teamId: $teamId, url: $url, secret: $secret, label: $label, resourceTypes: ["Issue"], enabled: true }) {
+    success
+    webhook { id url label enabled }
+  }
+}
+`, UPDATE_WEBHOOK_MUTATION = `
+mutation UpdateWebhook($id: String!, $url: String!, $enabled: Boolean!) {
+  webhookUpdate(id: $id, input: { url: $url, enabled: $enabled }) {
+    success
+    webhook { id url label enabled }
+  }
+}
+`;
+var init_linear_webhook_client = __esm(() => {
+  init_zod();
+  init_logger();
+  init_linear_client();
+  webhookNodeSchema = object({
+    id: string2(),
+    url: string2(),
+    label: string2().nullable().optional(),
+    enabled: boolean2()
+  });
+  listWebhooksDataSchema = object({
+    webhooks: object({
+      nodes: array(webhookNodeSchema)
+    }).optional()
+  });
+  webhookCreateDataSchema = object({
+    webhookCreate: object({
+      success: boolean2(),
+      webhook: webhookNodeSchema.optional()
+    }).optional()
+  });
+  webhookUpdateDataSchema = object({
+    webhookUpdate: object({
+      success: boolean2(),
+      webhook: webhookNodeSchema.optional()
+    }).optional()
+  });
+});
+
 // src/supervisor.ts
 init_yaml_loader();
 import { spawn as spawn3 } from "node:child_process";
@@ -15363,7 +15894,7 @@ async function registerLinearWebhook(root, tunnelUrl) {
   }
   const webhookUrl = `${tunnelUrl}/api/webhook`;
   try {
-    await Promise.resolve().then(() => init_linear_client());
+    await Promise.resolve().then(() => init_linear_webhook_client());
     const result = await upsertWebhook({
       apiKey: cfg.linearApiKey,
       teamId: cfg.linearTeamUuid,