@quantiya/codevibe-codex-plugin 2.0.72 → 2.0.74

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/cli.js

@@ -6741,6 +6741,11 @@ function invalid3() {
 function badResponse() {
   throw new SyncReadClientError("INVALID_SYNC_READ_RESPONSE");
 }
+function gatewayUnavailable(status, value) {
+  if (!closed3(value, ["message"]) || typeof value.message != "string") return !1;
+  let message = value.message.toLowerCase();
+  return [500, 502, 503, 504].includes(status) && message === "internal server error" || status === 429 && message === "too many requests";
+}
 function syncReadResponseError(value) {
   return (!plain4(value) || value.ok !== !1 || typeof value.errorCode != "string" || Object.keys(value).some((k) => !["ok", "errorCode", "retryAfterMs"].includes(k)) || value.retryAfterMs !== void 0 && (!Number.isSafeInteger(value.retryAfterMs) || value.retryAfterMs < 0)) && badResponse(), new SyncReadClientError(
     "SYNC_READ_UNAVAILABLE",
@@ -6770,7 +6775,7 @@ var DesktopSyncReadClient = class {
   }
   event(value) {
     let mobileInput = plain4(value) && value.source === "MOBILE" && ["USER_PROMPT", "PROMPT_RESPONSE"].includes(value.type), legacyStatusRevision = plain4(value) && value.deliveryStatus === "SENT" ? "0" : plain4(value) && value.deliveryStatus === "DELIVERED" ? "1" : plain4(value) && value.deliveryStatus === "EXECUTED" ? "2" : void 0, legacyInput = mobileInput && value.syncLegacyProjection === 1 && value.syncLifecycleVersion === void 0 && value.syncVisibility === "VISIBLE_METERED" && value.syncEventRevision === legacyStatusRevision && value.syncOperationId === void 0 && value.syncImmutableIdentityDigest === void 0;
-    return (!plain4(value) || typeof value.eventId != "string" || !ID2.test(value.eventId) || value.sessionId !== this.scope.sessionId || value.sessionGenerationId !== this.scope.sessionGenerationId || !timestamp2(value.timestamp) || typeof value.type != "string" || !/^[A-Z][A-Z0-9_]{0,63}$/.test(value.type) || !["DESKTOP", "MOBILE"].includes(value.source) || value.syncLegacyProjection !== void 0 && !legacyInput || mobileInput && value.syncLifecycleVersion !== 1 && !legacyInput || value.content !== void 0 && typeof value.content != "string" || value.metadata !== void 0 && typeof value.metadata != "string" || value.isEncrypted !== void 0 && typeof value.isEncrypted != "boolean" || value.isEncrypted === !0 && value.encryptionVersion !== 1 || Buffer.byteLength(JSON.stringify(value)) > 350 * 1024) && badResponse(), Object.freeze(value);
+    return (!plain4(value) || typeof value.eventId != "string" || !ID2.test(value.eventId) || value.sessionId !== this.scope.sessionId || value.sessionGenerationId !== this.scope.sessionGenerationId || !timestamp2(value.timestamp) || typeof value.type != "string" || !/^[A-Z][A-Z0-9_]{0,63}$/.test(value.type) || !["DESKTOP", "MOBILE"].includes(value.source) || value.syncLegacyProjection !== void 0 && !legacyInput || mobileInput && value.syncLifecycleVersion !== 1 && !legacyInput || value.content !== void 0 && typeof value.content != "string" || value.metadata !== void 0 && typeof value.metadata != "string" || value.isEncrypted !== void 0 && typeof value.isEncrypted != "boolean" || value.isEncrypted === !0 && value.encryptionVersion !== 1 && !(legacyInput && value.encryptionVersion === void 0) || Buffer.byteLength(JSON.stringify(value)) > 350 * 1024) && badResponse(), Object.freeze(value);
   }
   async request(method, path83, body, proofPayload, action, bound, headers, signal) {
     this.fence(signal);
@@ -6819,7 +6824,7 @@ var DesktopSyncReadClient = class {
         return badResponse();
       }
       if (!response.ok)
-        throw syncReadResponseError(value);
+        throw gatewayUnavailable(response.status, value) ? new SyncReadClientError("SYNC_READ_UNAVAILABLE") : syncReadResponseError(value);
       return { text: text2, value };
     } finally {
       controller.abort(), clearTimeout(timer), signal?.removeEventListener("abort", cancel);
@@ -10969,7 +10974,7 @@ function coerceAwsJsonObject(raw, op) {
 }
 var AppSyncGraphQLError = class extends Error {
   constructor(opts) {
-    super(`GraphQL error: ${opts.message}`), this.name = "AppSyncGraphQLError", this.responseMessage = opts.message, this.errorType = opts.errorType, this.data = opts.data, this.extensions = opts.extensions, this.path = opts.path;
+    super(`GraphQL error: ${opts.message}`), this.name = "AppSyncGraphQLError", this.responseMessage = opts.message, this.errorType = opts.errorType, this.extensions = opts.extensions, this.path = opts.path, this.data = opts.data, this.requestId = typeof opts.requestId == "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(opts.requestId) ? opts.requestId : void 0;
   }
 }, AppSyncAuthenticationError = class extends Error {
   constructor(kind) {
@@ -11032,6 +11037,8 @@ var AppSyncClient = class _AppSyncClient {
     this.syncDisplayAppliedSequence = 0;
     this.syncDisplay = null;
     this.syncDisplayListeners = /* @__PURE__ */ new Set();
+    this.syncStateRead = null;
+    this.syncStateRetry = null;
     /** Passive server-denial deadlines shared by existing source retry owners.
      * Exactly two producer families; no timer, durable state or admission grant. */
     this.syncProducerEpoch = 0;
@@ -11233,6 +11240,16 @@ var AppSyncClient = class _AppSyncClient {
   static throwIfAborted(signal) {
     if (signal?.aborted) throw _AppSyncClient.abortReason(signal);
   }
+  static async waitForSyncStateRetry(delayMs, signal) {
+    _AppSyncClient.throwIfAborted(signal), await new Promise((resolve28, reject) => {
+      let timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort), resolve28();
+      }, delayMs), onAbort = () => {
+        clearTimeout(timer), signal?.removeEventListener("abort", onAbort), reject(_AppSyncClient.abortReason(signal));
+      };
+      signal?.addEventListener("abort", onAbort, { once: !0 }), signal?.aborted && onAbort();
+    });
+  }
   /**
    * Bound one stage by its owning operation's absolute deadline. Every stage
    * receives the same `deadlineAtMs`; a storage-backed retry therefore consumes
@@ -11518,7 +11535,7 @@ var AppSyncClient = class _AppSyncClient {
    */
   async graphqlRequest(query, variables, isRetry = !1, signal, expectedUserId, maxResponseBytes, beforeSend) {
     _AppSyncClient.throwIfAborted(signal), expectedUserId !== void 0 && this.assertSyncAccount(expectedUserId);
-    let config = getConfig();
+    let syncUserId = this.currentUserId, syncEpoch = this.syncDisplayEpoch, config = getConfig();
     if (!this.tokens?.idToken)
       throw new Error('Not authenticated. Run "codevibe login" first.');
     let headers = {
@@ -11552,12 +11569,22 @@ var AppSyncClient = class _AppSyncClient {
     let result = maxResponseBytes === void 0 ? await response.json() : await this.boundedGraphQLJson(response, maxResponseBytes, signal);
     if (expectedUserId !== void 0 && this.assertSyncAccount(expectedUserId), result.errors?.length) {
       let first = result.errors[0];
-      throw new AppSyncGraphQLError({
+      throw [
+        mutations.createEvent,
+        mutations.updateEventStatus,
+        mutations.recordWorkspaceOutcomeV2,
+        mutations.reportSecurityPostureV2,
+        queries.listEvents,
+        queries.listSupervisionEvents,
+        queries.getGateResolution,
+        queries.getGateResolutionV2
+      ].includes(query) && syncUserId === this.currentUserId && syncEpoch === this.syncDisplayEpoch && ["UPDATE_REQUIRED", "AUTHORITY_UNAVAILABLE", "SYNC_BLOCKED"].includes(first.errorType ?? "") && this.resetCompanionSyncDisplay(), new AppSyncGraphQLError({
         message: first.message,
         errorType: first.errorType,
-        data: first.data,
         extensions: first.extensions,
-        path: first.path
+        path: first.path,
+        data: first.data,
+        requestId: response.headers?.get("x-amzn-requestid")
       });
     }
     return result;
@@ -11596,15 +11623,70 @@ var AppSyncClient = class _AppSyncClient {
     if (!this.authenticated || this.currentUserId !== userId || this.tokens?.userId !== userId)
       throw new SyncEventClientError("SYNC_ACCOUNT_CHANGED");
   }
-  /** Bounded cloud routing/usage read, pinned to the current account. No fallback. */
+  /** Concurrent fresh reads share one account/epoch-bound request and retry
+   * loop. Sequential status/quota reads remain fresh; one cancelled caller
+   * cannot cancel another caller's read. No cached admission authority. */
   async getCompanionSyncState(signal) {
-    let userId = this.getCurrentUserId();
+    let userId = this.getCurrentUserId(), epoch = this.syncDisplayEpoch, check = () => {
+      if (this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal), epoch !== this.syncDisplayEpoch) throw new SyncEventClientError("INVALID_SYNC_STATE");
+    };
+    check();
+    let flight = this.syncStateRead;
+    if (!flight || flight.userId !== userId || flight.epoch !== epoch || flight.controller.signal.aborted) {
+      let controller = new AbortController();
+      flight = { userId, epoch, controller, promise: this.readCompanionSyncState(userId, epoch, controller.signal), waiters: 0, settled: !1 }, this.syncStateRead = flight;
+      let owned2 = flight, settled = () => {
+        owned2.settled = !0, this.syncStateRead === owned2 && (this.syncStateRead = null);
+      };
+      owned2.promise.then(settled, settled);
+    }
+    let owned = flight;
+    return owned.waiters++, new Promise((resolve28, reject) => {
+      let finished = !1, finish = (error) => {
+        if (!finished) {
+          finished = !0, signal?.removeEventListener("abort", onAbort), --owned.waiters === 0 && !owned.settled && (this.syncStateRead === owned && (this.syncStateRead = null), owned.controller.abort(new Error("Sync state read has no callers")));
+          try {
+            if (check(), error !== void 0) throw error;
+            let state = this.companionSyncStatusSnapshot(userId);
+            if (!state) throw new SyncEventClientError("INVALID_SYNC_STATE");
+            resolve28(state);
+          } catch (failure2) {
+            reject(failure2);
+          }
+        }
+      }, onAbort = () => finish(_AppSyncClient.abortReason(signal));
+      signal?.addEventListener("abort", onAbort, { once: !0 }), owned.promise.then(() => finish(), (error) => finish(error)), signal?.aborted && onAbort();
+    });
+  }
+  /** Only explicit HISTORY_RETRY_AFTER permits two retries / ten seconds of
+   * added wait. Retain the server's earliest retry time after cancellation or
+   * exhaustion so a later caller cannot restart I/O before that time. */
+  async readCompanionSyncState(userId, epoch, signal) {
     this.assertSyncAccount(userId);
-    let epoch = this.syncDisplayEpoch, sequence = ++this.syncDisplaySequence;
+    let sequence = ++this.syncDisplaySequence;
     try {
-      _AppSyncClient.throwIfAborted(signal);
-      let response = await this.graphqlRequest(queries.getCompanionSyncState, {}, !1, signal, userId);
-      this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal);
+      let response, retries = 0, waitedMs = 0;
+      for (; ; ) {
+        this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal);
+        let cooldown = this.syncStateRetry;
+        if (cooldown?.userId === userId && cooldown.epoch === epoch) {
+          let delayMs = cooldown.retryAtMs - Date.now();
+          if (delayMs > 1e4 - waitedMs) throw cooldown.error;
+          delayMs > 0 && (waitedMs += delayMs, await _AppSyncClient.waitForSyncStateRetry(delayMs, signal), this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal));
+        }
+        try {
+          response = await this.graphqlRequest(queries.getCompanionSyncState, {}, !1, signal, userId);
+          break;
+        } catch (error) {
+          this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal);
+          let data = error instanceof AppSyncGraphQLError ? error.data : void 0, retryAfterMs = data && typeof data == "object" && !Array.isArray(data) ? data.retryAfterMs : void 0;
+          if (!(error instanceof AppSyncGraphQLError) || error.errorType !== "HISTORY_RETRY_AFTER" || typeof retryAfterMs != "number" || !Number.isSafeInteger(retryAfterMs) || retryAfterMs < 0) throw error;
+          let retryAtMs = Date.now() + Math.max(1, retryAfterMs);
+          if (!Number.isSafeInteger(retryAtMs) || (this.syncStateRetry = { userId, epoch, retryAtMs, error }, retries >= 2)) throw error;
+          retries++;
+        }
+      }
+      this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal), this.syncStateRetry?.userId === userId && this.syncStateRetry.epoch === epoch && (this.syncStateRetry = null);
       let state = parseCompanionSyncState(response?.data?.getCompanionSyncState, this.environment), effective = this.publishCompanionSyncDisplay(userId, state, epoch, sequence), now = Date.now();
       if (!effective || !Number.isSafeInteger(now) || effective.observedAtEpochMs > now + SYNC_STATE_CLOCK_SKEW_MS || effective.validUntilEpochMs <= now)
         throw new SyncEventClientError("INVALID_SYNC_STATE");
@@ -11613,6 +11695,19 @@ var AppSyncClient = class _AppSyncClient {
       throw this.publishCompanionSyncDisplay(userId, null, epoch, sequence), error;
     }
   }
+  /** Reuse only the server-unexpired protocol selection, never its entitlement
+   * or usage as admission authority. Every selected cloud operation still
+   * authorizes itself. Explicit status/quota refreshes remain fresh reads. */
+  async getCompanionSyncRoute(signal) {
+    let userId = this.getCurrentUserId(), epoch = this.syncDisplayEpoch, check = () => {
+      if (this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal), epoch !== this.syncDisplayEpoch) throw new SyncEventClientError("INVALID_SYNC_STATE");
+    };
+    check();
+    let cached = this.companionSyncStatusSnapshot(userId);
+    if (cached) return { protocol: cached.protocol };
+    let state = await this.getCompanionSyncState(signal);
+    return check(), { protocol: state.protocol };
+  }
   /** Subscribe to validated reads already performed by this client. No new
    * request, persistent journal, producer grant or retry is created here. */
   subscribeCompanionSyncState(userId, listener) {
@@ -11645,7 +11740,9 @@ var AppSyncClient = class _AppSyncClient {
     this.syncProducerEpoch++, this.syncProducerRetry.clear();
   }
   resetCompanionSyncDisplay() {
-    this.syncDisplayEpoch += 1, this.syncDisplay = null, this.syncDisplayAppliedSequence = this.syncDisplaySequence;
+    this.syncDisplayEpoch += 1;
+    let flight = this.syncStateRead;
+    this.syncStateRead = null, this.syncStateRetry = null, flight?.controller.abort(new Error("Sync routing observation invalidated")), this.syncDisplay = null, this.syncDisplayAppliedSequence = this.syncDisplaySequence;
     for (let entry5 of this.syncDisplayListeners) this.notifyCompanionSyncDisplay(entry5);
   }
   publishCompanionSyncDisplay(userId, state, epoch, sequence) {
@@ -11671,7 +11768,7 @@ var AppSyncClient = class _AppSyncClient {
       posture
     }, userId = this.getCurrentUserId();
     this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal);
-    let state = await this.getCompanionSyncState(signal);
+    let state = await this.getCompanionSyncRoute(signal);
     if (this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal), state.protocol === "LEGACY") return null;
     if (state.protocol !== "SYNC_V2") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
     if (!scope.sessionGenerationId) throw new SyncEventClientError("SYNC_SESSION_GENERATION_CHANGED");
@@ -11699,7 +11796,7 @@ var AppSyncClient = class _AppSyncClient {
   async desktopSyncReadClient(sessionScope, signal) {
     let scope = { ...sessionScope }, userId = this.getCurrentUserId();
     this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal);
-    let state = await this.getCompanionSyncState(signal);
+    let state = await this.getCompanionSyncRoute(signal);
     if (this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal), state.protocol !== "SYNC_V2") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
     let config = getConfig();
     if (config.environment !== this.environment || !config.aws.syncHttpUrl) throw new SyncEventClientError("SYNC_SESSION_UNAVAILABLE");
@@ -12006,13 +12103,13 @@ var AppSyncClient = class _AppSyncClient {
       getEncryptionContext: selected.getEncryptionContext
     });
   }
-  /** Shared cloud-selected authority for tools and ordinary native sources. */
+  /** Shared cloud-selected routing for tools and ordinary native sources. */
   async selectCompanionSourceTransport(options) {
     let { sessionId, root } = options;
     if (typeof sessionId != "string" || !/^[A-Za-z0-9_-]{1,256}$/.test(sessionId)) throw new SyncEventClientError("INVALID_SYNC_INPUT");
     let userId = this.getCurrentUserId();
     this.assertSyncAccount(userId);
-    let state = await this.getCompanionSyncState();
+    let state = await this.getCompanionSyncRoute();
     if (this.assertSyncAccount(userId), state.protocol === "FROZEN") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
     if (state.protocol === "LEGACY") return Object.freeze({ protocol: "LEGACY" });
     let readSession = async () => {
@@ -12161,12 +12258,12 @@ var AppSyncClient = class _AppSyncClient {
       let resolutions = await writer.promptResolutions();
       check();
       let knownV2 = [...publications, ...resolutions].some((row3) => row3.sessionId === input.sessionId && row3.promptId === input.promptId), durable = (control, selected) => writer.runPromptResolution(control, async (saved, fence) => {
-        let state2 = selected ?? await this.getCompanionSyncState();
+        let state2 = selected ?? await this.getCompanionSyncRoute();
         if (await fence(), state2.protocol !== "SYNC_V2") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
         return this.finishPromptResolution(saved, options, fence);
       });
       if (knownV2) return durable(prepareV2());
-      let state = await this.getCompanionSyncState();
+      let state = await this.getCompanionSyncRoute();
       if (check(), state.protocol === "LEGACY")
         return this.resolvePromptPublication(input, async (hasV2Publication) => {
           if (hasV2Publication || (await writer.promptResolutions()).some((row3) => row3.sessionId === input.sessionId && row3.promptId === input.promptId))
@@ -12197,7 +12294,7 @@ var AppSyncClient = class _AppSyncClient {
       check();
       let records = (await writer.promptResolutions()).filter((row3) => row3.sessionId === sessionId);
       if (check(), !records.length) return 0;
-      let state = await this.getCompanionSyncState(signal);
+      let state = await this.getCompanionSyncRoute(signal);
       if (check(), state.protocol !== "SYNC_V2") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
       let completed = 0, firstFailure;
       for (let input of records) {
@@ -12631,7 +12728,7 @@ var AppSyncClient = class _AppSyncClient {
   async submitWorkspaceOutcome(value, options = {}) {
     let input = snapshotWorkspaceOutcomeInput(value), userId = this.getCurrentUserId();
     this.assertSyncAccount(userId);
-    let route = await this.getCompanionSyncState();
+    let route = await this.getCompanionSyncRoute();
     if (this.assertSyncAccount(userId), route.protocol === "FROZEN") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
     if (route.protocol === "LEGACY") {
       if (options.requiresV2) throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
@@ -12735,7 +12832,7 @@ var AppSyncClient = class _AppSyncClient {
           source: "MOBILE" /* MOBILE */,
           type: expected.type
         }), this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal));
-    let route = await this.getCompanionSyncState(signal);
+    let route = await this.getCompanionSyncRoute(signal);
     if (this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal), route.protocol === "FROZEN") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
     if (requiredSessionGenerationId !== void 0 && route.protocol !== "SYNC_V2") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
     if (route.protocol === "LEGACY") {
@@ -12763,7 +12860,7 @@ var AppSyncClient = class _AppSyncClient {
    * List events for a session
    */
   async listEvents(sessionId, source2, limit) {
-    let route = await this.getCompanionSyncState();
+    let route = await this.getCompanionSyncRoute();
     if (route.protocol === "FROZEN") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
     if (route.protocol === "SYNC_V2") {
       if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)) throw new SyncEventClientError("INVALID_SYNC_INPUT");
@@ -12777,7 +12874,7 @@ var AppSyncClient = class _AppSyncClient {
    * can merge each page through the same strict event classifier as live data.
    */
   async listSupervisionEvents(input) {
-    let route = await this.getCompanionSyncState();
+    let route = await this.getCompanionSyncRoute();
     if (route.protocol === "FROZEN") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
     if (route.protocol === "SYNC_V2") {
       if (input.limit !== void 0 && input.limit !== 100) throw new SyncEventClientError("INVALID_SYNC_INPUT");
@@ -13226,7 +13323,7 @@ var AppSyncClient = class _AppSyncClient {
   async getGateResolution(input) {
     let expected = { ...input }, userId = this.getCurrentUserId(), epoch = this.syncReadEpoch;
     this.assertSyncAccount(userId), this.assertSyncReadAdmission(expected.sessionId);
-    let route = await this.getCompanionSyncState();
+    let route = await this.getCompanionSyncRoute();
     if (this.assertSyncAccount(userId), this.assertSyncReadAdmission(expected.sessionId), epoch !== this.syncReadEpoch) throw new SyncEventClientError("SYNC_SESSION_UNAVAILABLE");
     if (route.protocol === "LEGACY") {
       let response = await this.graphqlRequest(
@@ -14258,7 +14355,7 @@ var AppSyncClient = class _AppSyncClient {
   createSubscription(state) {
     let abort = state.setupAbort = new AbortController(), current = () => !state.destroyed && !abort.signal.aborted && this.activeSubscriptions.get(state.sessionId) === state, setup = (async () => {
       if (await this.joinSyncSubscriptionClosures(state.sessionId), !current()) return;
-      let userId = this.getCurrentUserId(), route = await this.getCompanionSyncState(abort.signal);
+      let userId = this.getCurrentUserId(), route = await this.getCompanionSyncRoute(abort.signal);
       if (!current()) return;
       if (this.assertSyncAccount(userId), route.protocol === "FROZEN") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
       if (route.protocol === "LEGACY") {
@@ -76592,7 +76689,7 @@ async function runLocalDecomposer(deps, brief, availableAgents, repoContext) {
       timeoutMs: null,
       stdinTty: !0,
       stdinPayload: prompt
-    }), exit = await handle.done, text2 = await readImplementorFinalMessage(plan, handle, agent, exit.exitCode, deps.workingDir), usage = agent === "CLAUDE" && text2.length === 0 ? unwrapClaudeJson(handle.stdout()).usage : void 0, providerError = usage?.availability === "unavailable" && usage.unavailableReason === "provider_error";
+    }), exit = await handle.done, text2 = await readImplementorFinalMessage(plan, handle, agent, exit.exitCode, deps.workingDir), providerError = (agent === "CLAUDE" && text2.length === 0 ? firstResultEnvelope(handle.stdout()) : null)?.is_error === !0;
     return { text: text2, providerError };
   };
   try {
@@ -76608,7 +76705,10 @@ async function runLocalDecomposer(deps, brief, availableAgents, repoContext) {
       agent,
       attempt: 2,
       ...describeDecomposerReply(second.text, second)
-    }), { decompose: !1, reason: "decomposer output could not be parsed" });
+    }), {
+      decompose: !1,
+      reason: second.providerError ? "decomposer provider error" : "decomposer output could not be parsed"
+    });
   } catch (err) {
     return logger.warn("[team-decompose] decomposer spawn failed \u2014 single-task fallback", {
       agent,
@@ -77347,10 +77447,47 @@ var OrchestrationShellStartupError = class extends Error {
     super(message), this.name = "OrchestrationShellStartupError", this.cause = cause;
   }
 }, STARTUP_SUBSCRIPTION_TIMEOUT_MS = 15e3;
+function logStartupFailure(boundary, errorValue, reason) {
+  try {
+    let error = errorValue, classes = [
+      "AppSyncGraphQLError",
+      "AppSyncAuthenticationError",
+      "SyncEventClientError",
+      "SyncReadClientError",
+      "Error",
+      "TypeError"
+    ], codes = [
+      "HISTORY_RETRY_AFTER",
+      "CONTROL_BREAKER_CONTENTION",
+      "AUTHORITY_UNAVAILABLE",
+      "INVALID_SYNC_STATE",
+      "INVALID_SYNC_READ_RESPONSE",
+      "SYNC_PRODUCER_FROZEN",
+      "SYNC_ACCOUNT_CHANGED",
+      "SYNC_SESSION_UNAVAILABLE",
+      "EPERM",
+      "EACCES",
+      "ENOENT",
+      "ENETUNREACH",
+      "EAI_AGAIN",
+      "ECONNREFUSED",
+      "ECONNRESET",
+      "ETIMEDOUT"
+    ], code = [error?.errorType, error?.code].find((value) => typeof value == "string" && codes.includes(value)), requestId = typeof error?.requestId == "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(error.requestId) ? error.requestId : void 0, delay = error?.data?.retryAfterMs, retryAfterMs = code === "HISTORY_RETRY_AFTER" && typeof delay == "number" && Number.isSafeInteger(delay) && delay >= 0 ? delay : void 0;
+    logger.warn(`[orchestration-shell] startup ${boundary} failed`, {
+      ...reason !== void 0 && { reason },
+      errorClass: typeof error?.name == "string" && classes.includes(error.name) ? error.name : "UNKNOWN",
+      errorCode: code ?? "UNKNOWN",
+      ...requestId && { requestId },
+      ...retryAfterMs !== void 0 && { retryAfterMs }
+    });
+  } catch {
+  }
+}
 function startupEventFailure(result) {
   if (result.emitted)
     return new OrchestrationShellStartupError("Unexpected successful startup event result");
-  switch (result.reason) {
+  switch (logStartupFailure("event", result.error, result.reason), result.reason) {
     case "missing_session_key":
       return new OrchestrationShellStartupError(
         "CodeVibe could not access the orchestration session encryption key. Exit and launch CodeVibe again; if the problem persists, run `codevibe login`.",
@@ -77889,7 +78026,7 @@ async function runOrchestrationShell(args) {
       // an event actually arrives (async) — never during this synchronous setup.
       subscribedEventDispatcher,
       (err) => {
-        initialCatchUpStarted && rejectInitialSubscription(err), logger.warn("[orchestration-shell] subscribeToEvents error", {
+        initialSubscriptionSettled || logStartupFailure("subscription", err), initialCatchUpStarted && rejectInitialSubscription(err), logger.warn("[orchestration-shell] subscribeToEvents error", {
           error: err.message
         });
       },
@@ -86501,7 +86638,17 @@ var ANTHROPIC_VERSION = "2023-06-01", ANTHROPIC_BETA_ALLOWLIST = /* @__PURE__ */
   // Note: advisor-tool-2026-03-01 is deliberately EXCLUDED (unneeded and prevents account-billed advisor tool invocation).
   "thinking-token-count-2026-05-13",
   "per-turn-control-2026-07-01",
-  "mid-conversation-tool-changes-2026-07-01"
+  "mid-conversation-tool-changes-2026-07-01",
+  // Reviewed 2026-10-14 (CP-7 decomposer dogfood): Empirically captured from live
+  // Claude Code CLI 2.1.299 requests on /v1/messages (`model: "claude-opus-5-5"`).
+  // Claude Code 2.1.299 sends `safeguards: [{ type: "dangerous_tool_use", ... }]` in the
+  // request body; dropping `dangerous-tool-use-2026-09-03` causes upstream Anthropic to
+  // return HTTP 400 (`invalid_request_error`: `"safeguards: Extra inputs are not permitted"`).
+  // `buildCanonicalRequest` in `canonical.ts` validates `$.safeguards` fail-closed against
+  // the 24-key Claude Code 2.1.299 `z1s`/`W3n`/`rmt`/`q1s`/`K1s`/`hmt`/`qOr` schema (and runs
+  // before `scanRequestForBrokerCredentials` and `scrubRequestPayload`).
+  // Note: `afk-mode-2026-01-31` is deliberately EXCLUDED (empirically verified unnecessary).
+  "dangerous-tool-use-2026-09-03"
 ]), PROVIDER_CONFIGS = {
   anthropic: {
     upstreamBaseUrl: "https://api.anthropic.com",
@@ -86677,6 +86824,642 @@ function hasOwn(obj, key) {
 function requestSha256(body) {
   return (0, import_node_crypto35.createHash)("sha256").update(JSON.stringify(body)).digest("hex");
 }
+var SAFE_SAFEGUARD_ENTRY_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "classifier_context"
+]), SAFE_CLASSIFIER_CONTEXT_KEYS = /* @__PURE__ */ new Set([
+  // Exact 16 base keys emitted by Claude Code 2.1.299 `mts` + `qOr` (`dangerous_tool_use` classifier_context):
+  "v",
+  "permission_mode",
+  "platform",
+  "live_cwd",
+  "home_dir",
+  "rule_roots",
+  "trusted_directories",
+  "rules",
+  "auto_mode",
+  "artifact_consent_holdback",
+  "case_insensitive_paths",
+  "restricted",
+  "is_remote_mode",
+  "classify_all_shell",
+  "user_identity",
+  "git_state",
+  // Exact 8 conditional keys emitted by Claude Code 2.1.299 `mts` (offset 202112500) and `qOr` (offset 205163100)
+  // on multi-turn / tool-result / reminder / artifact / byte-budget turns:
+  "dropped",
+  "truncated",
+  "chrome_navigation",
+  "prior_turn_context",
+  "system_reminders",
+  "artifacts",
+  "shed",
+  "tool_host_attached"
+]), CLASSIFIER_STRING_KEYS = [
+  "permission_mode",
+  "platform",
+  "live_cwd",
+  "home_dir"
+], CLASSIFIER_BOOLEAN_KEYS = [
+  "artifact_consent_holdback",
+  "case_insensitive_paths",
+  "restricted",
+  "is_remote_mode",
+  "classify_all_shell",
+  "truncated",
+  "tool_host_attached"
+], SAFE_RULE_ROOT_KEYS = /* @__PURE__ */ new Set([
+  "userSettings",
+  "projectSettings",
+  "localSettings",
+  "flagSettings",
+  "policySettings",
+  "cliArg",
+  "command",
+  "session",
+  "toolsNarrowing",
+  "mcpServerPolicy",
+  "hostCredential"
+]), SAFE_TRUSTED_DIRECTORIES_KEYS = /* @__PURE__ */ new Set([
+  "primary",
+  "additional",
+  "network",
+  "block_reads_outside_working_directories"
+]), SAFE_TRUSTED_DIRECTORY_ENTRY_KEYS = /* @__PURE__ */ new Set([
+  "path",
+  "resolved",
+  "source"
+]), SAFE_RULES_KEYS = /* @__PURE__ */ new Set([
+  "allow",
+  "deny",
+  "ask"
+]), SAFE_DROPPED_KEYS = /* @__PURE__ */ new Set([
+  "allow",
+  "deny",
+  "ask",
+  "auto_mode_allow",
+  "auto_mode_soft_deny",
+  "auto_mode_hard_deny",
+  "auto_mode_environment"
+]), SAFE_RULE_ITEM_KEYS = /* @__PURE__ */ new Set([
+  "rule",
+  "canonical",
+  "source",
+  "root",
+  "pattern"
+]), SAFE_AUTO_MODE_KEYS = /* @__PURE__ */ new Set([
+  "allow",
+  "soft_deny",
+  "hard_deny",
+  "environment"
+]), SAFE_GIT_STATE_KEYS = /* @__PURE__ */ new Set([
+  "cwd",
+  "root",
+  "branch",
+  "default_branch",
+  "status",
+  "visibility",
+  "error",
+  "truncated"
+]), SAFE_GIT_ERROR_VALUES = /* @__PURE__ */ new Set([
+  "timeout",
+  "not_a_repo",
+  "error",
+  "pending"
+]), SAFE_GIT_STATUS_KEYS = /* @__PURE__ */ new Set([
+  "clean",
+  "counts",
+  "porcelain",
+  "truncated"
+]), SAFE_GIT_COUNTS_KEYS = /* @__PURE__ */ new Set([
+  "staged",
+  "modified",
+  "untracked",
+  "untracked_normal"
+]), SAFE_GIT_VISIBILITY_KEYS = /* @__PURE__ */ new Set([
+  "origin",
+  "push_remote",
+  "remotes",
+  "visibility_cache"
+]), SAFE_GIT_REPO_VISIBILITY_VALUES = /* @__PURE__ */ new Set([
+  "public",
+  "private",
+  "unknown"
+]), SAFE_GIT_ORIGIN_KEYS = /* @__PURE__ */ new Set([
+  "host",
+  "remote",
+  "visibility"
+]), SAFE_GIT_REMOTE_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "host",
+  "remote",
+  "visibility"
+]), SAFE_CHROME_NAVIGATION_KEYS = /* @__PURE__ */ new Set([
+  "enabled",
+  "baselines",
+  "tabs"
+]), SAFE_PRIOR_TURN_ENTRY_KEYS = /* @__PURE__ */ new Set([
+  "tool_use_ids",
+  "context"
+]), SAFE_PRIOR_TURN_INNER_CONTEXT_KEYS = /* @__PURE__ */ new Set([
+  "git_state",
+  "chrome_navigation",
+  "live_cwd",
+  "platform"
+]), SAFE_SYSTEM_REMINDER_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "provenance",
+  "author",
+  "written"
+]), SAFE_ARTIFACTS_KEYS = /* @__PURE__ */ new Set([
+  "by_slug",
+  "by_path",
+  "live_docs",
+  "room_armed",
+  "type_reads",
+  "last_publish",
+  "session",
+  "truncated"
+]), SAFE_ARTIFACT_ENV_VALUES = /* @__PURE__ */ new Set([
+  "prod",
+  "staging"
+]), SAFE_ARTIFACT_WATCH_RAIL_VALUES = /* @__PURE__ */ new Set([
+  "live",
+  "durable",
+  "none"
+]), SAFE_ARTIFACT_SLUG_ENTRY_KEYS = /* @__PURE__ */ new Set([
+  "share",
+  "attested",
+  "notice_pending",
+  "published_env",
+  "watch"
+]), SAFE_ARTIFACT_WATCH_KEYS = /* @__PURE__ */ new Set([
+  "stopped",
+  "auto_reply_stopped",
+  "auto_reply_swept",
+  "replies_declined"
+]), SAFE_ARTIFACT_SHARE_KEYS = /* @__PURE__ */ new Set([
+  "mode",
+  "is_shared_live",
+  "role",
+  "probe_failed",
+  "probed",
+  "probe_current_account",
+  "cowritten",
+  "outside_writer",
+  "artifact_kind",
+  "type_locked",
+  "type_lock",
+  "type_first_party",
+  "caps_read_not_found",
+  "live_paths",
+  "capabilities",
+  "capabilities_unknown",
+  "capabilities_cut",
+  "grant_observed"
+]), SAFE_ARTIFACT_SHARE_TRUE_LITERAL_KEYS = [
+  "probe_failed",
+  "cowritten",
+  "outside_writer",
+  "type_locked",
+  "type_first_party",
+  "caps_read_not_found",
+  "capabilities_unknown",
+  "capabilities_cut"
+], SAFE_ARTIFACT_PATH_ENTRY_KEYS = /* @__PURE__ */ new Set([
+  "slug",
+  "thumbnail_named"
+]), SAFE_ARTIFACT_LIVE_DOC_KEYS = /* @__PURE__ */ new Set([
+  "slug",
+  "live_path",
+  "working_copy"
+]), SAFE_ARTIFACT_TYPE_READ_KEYS = /* @__PURE__ */ new Set([
+  "declares_room"
+]), SAFE_ARTIFACT_LAST_PUBLISH_KEYS = /* @__PURE__ */ new Set([
+  "slug",
+  "env"
+]), SAFE_ARTIFACT_SESSION_KEYS = /* @__PURE__ */ new Set([
+  "frame_env",
+  "viewer_origin",
+  "dev_viewer_origin",
+  "toolset",
+  "short_links",
+  "ant_build",
+  "live_edit",
+  "live_doc_stream",
+  "live_paths_schema",
+  "copy_from",
+  "types_on",
+  "five_class_asks",
+  "inherited_type_grant",
+  "watch_rail",
+  "auto_react",
+  "comments_in_schema",
+  "db_str_replace",
+  "handlers",
+  "room_client",
+  "eval_stub",
+  "scratchpad_dir",
+  "tool_results_dir"
+]), SAFE_ARTIFACT_SESSION_REQUIRED_BOOLEAN_KEYS = [
+  "ant_build",
+  "comments_in_schema",
+  "handlers",
+  "room_client",
+  "eval_stub"
+], SAFE_ARTIFACT_SESSION_OPTIONAL_BOOLEAN_KEYS = [
+  "toolset",
+  "short_links",
+  "live_edit",
+  "live_doc_stream",
+  "live_paths_schema",
+  "copy_from",
+  "types_on",
+  "five_class_asks",
+  "auto_react",
+  "db_str_replace"
+], MAX_SAFEGUARDS_ENTRIES = 16;
+function isPlainObject(val) {
+  return val !== null && typeof val == "object" && !Array.isArray(val);
+}
+function isFiniteNumber(val) {
+  return typeof val == "number" && Number.isFinite(val);
+}
+function isStringArray(val) {
+  return Array.isArray(val) && val.every((item2) => typeof item2 == "string");
+}
+function isStringRecord(val) {
+  if (!isPlainObject(val)) return !1;
+  for (let k of Object.keys(val))
+    if (typeof val[k] != "string") return !1;
+  return !0;
+}
+function isValidTrustedDirEntry(val) {
+  if (!isPlainObject(val)) return !1;
+  let keys = Object.keys(val);
+  for (let k of keys)
+    if (!SAFE_TRUSTED_DIRECTORY_ENTRY_KEYS.has(k)) return !1;
+  return !(!hasOwn(val, "path") || typeof val.path != "string" || !hasOwn(val, "resolved") || !isStringArray(val.resolved) || hasOwn(val, "source") && val.source !== void 0 && typeof val.source != "string");
+}
+function isValidGitOriginOrCacheEntry(val) {
+  if (!isPlainObject(val)) return !1;
+  for (let k of Object.keys(val))
+    if (!SAFE_GIT_ORIGIN_KEYS.has(k)) return !1;
+  return !(!hasOwn(val, "host") || typeof val.host != "string" || !hasOwn(val, "remote") || typeof val.remote != "string" || !hasOwn(val, "visibility") || typeof val.visibility != "string" || !SAFE_GIT_REPO_VISIBILITY_VALUES.has(val.visibility));
+}
+function isValidGitRemoteEntry(val) {
+  if (!isPlainObject(val)) return !1;
+  for (let k of Object.keys(val))
+    if (!SAFE_GIT_REMOTE_KEYS.has(k)) return !1;
+  return !(!hasOwn(val, "name") || typeof val.name != "string" || !hasOwn(val, "host") || typeof val.host != "string" || !hasOwn(val, "remote") || typeof val.remote != "string" || !hasOwn(val, "visibility") || typeof val.visibility != "string" || !SAFE_GIT_REPO_VISIBILITY_VALUES.has(val.visibility));
+}
+function isValidGitState(val) {
+  if (!isPlainObject(val)) return !1;
+  for (let gk of Object.keys(val)) {
+    if (!SAFE_GIT_STATE_KEYS.has(gk)) return !1;
+    let gv = val[gk];
+    if (gk === "cwd" || gk === "root" || gk === "branch" || gk === "default_branch") {
+      if (gv != null && typeof gv != "string") return !1;
+    } else if (gk === "error") {
+      if (gv != null && (typeof gv != "string" || !SAFE_GIT_ERROR_VALUES.has(gv)))
+        return !1;
+    } else if (gk === "truncated") {
+      if (gv !== void 0 && typeof gv != "boolean") return !1;
+    } else if (gk === "status") {
+      if (gv != null) {
+        if (!isPlainObject(gv)) return !1;
+        for (let sk of Object.keys(gv))
+          if (!SAFE_GIT_STATUS_KEYS.has(sk)) return !1;
+        if (!hasOwn(gv, "clean") || typeof gv.clean != "boolean" || !hasOwn(gv, "truncated") || typeof gv.truncated != "boolean" || !hasOwn(gv, "porcelain") || gv.porcelain !== null && typeof gv.porcelain != "string" || !hasOwn(gv, "counts")) return !1;
+        if (gv.counts !== null) {
+          if (!isPlainObject(gv.counts)) return !1;
+          for (let ck of Object.keys(gv.counts))
+            if (!SAFE_GIT_COUNTS_KEYS.has(ck)) return !1;
+          if (!hasOwn(gv.counts, "staged") || !isFiniteNumber(gv.counts.staged) || !hasOwn(gv.counts, "modified") || !isFiniteNumber(gv.counts.modified) || !hasOwn(gv.counts, "untracked") || gv.counts.untracked !== null && !isFiniteNumber(gv.counts.untracked) || !hasOwn(gv.counts, "untracked_normal") || gv.counts.untracked_normal !== null && !isFiniteNumber(gv.counts.untracked_normal))
+            return !1;
+        }
+      }
+    } else if (gk === "visibility" && gv != null) {
+      if (!isPlainObject(gv)) return !1;
+      for (let vk of Object.keys(gv))
+        if (!SAFE_GIT_VISIBILITY_KEYS.has(vk)) return !1;
+      if (!hasOwn(gv, "origin") || gv.origin !== null && !isValidGitOriginOrCacheEntry(gv.origin) || !hasOwn(gv, "push_remote") || gv.push_remote !== null && typeof gv.push_remote != "string" || !hasOwn(gv, "remotes") || !Array.isArray(gv.remotes) || !gv.remotes.every(isValidGitRemoteEntry) || !hasOwn(gv, "visibility_cache") || !Array.isArray(gv.visibility_cache) || !gv.visibility_cache.every(isValidGitOriginOrCacheEntry))
+        return !1;
+    }
+  }
+  return !0;
+}
+function isValidChromeNavigation(val) {
+  if (!isPlainObject(val)) return !1;
+  for (let ck of Object.keys(val))
+    if (!SAFE_CHROME_NAVIGATION_KEYS.has(ck)) return !1;
+  if (!hasOwn(val, "enabled") || typeof val.enabled != "boolean" || !hasOwn(val, "baselines") || !isStringRecord(val.baselines)) return !1;
+  if (hasOwn(val, "tabs") && val.tabs !== void 0) {
+    if (!isPlainObject(val.tabs)) return !1;
+    for (let tk of Object.keys(val.tabs))
+      if (!isStringRecord(val.tabs[tk])) return !1;
+  }
+  return !0;
+}
+var SAFE_ARTIFACT_RULE_CAPABILITY_KEYS = /* @__PURE__ */ new Set([
+  "artifact",
+  "self",
+  "downloads",
+  "comments",
+  "room",
+  "db",
+  "assets"
+]), SAFE_ARTIFACT_CAPABILITY_KEYS = /* @__PURE__ */ new Set([
+  ...SAFE_ARTIFACT_RULE_CAPABILITY_KEYS,
+  "user",
+  "mcp",
+  "flags"
+]), MAX_ARTIFACT_CAPABILITIES_BYTES = 4e3, MAX_ARTIFACT_MCP_SERVERS = 32, MAX_ARTIFACT_MCP_TOOLS = 128, SAFE_ARTIFACT_MCP_TOOL_RE = /^[A-Za-z0-9_.-]{1,128}$/, SAFE_ARTIFACT_MCP_CAP_KEYS = /* @__PURE__ */ new Set(["servers", "dynamic"]), SAFE_ARTIFACT_MCP_SERVER_KEYS = /* @__PURE__ */ new Set(["server", "tools"]), SAFE_ARTIFACT_RULE_OBJECT_KEYS = /* @__PURE__ */ new Set(["rules", "wake"]), SAFE_ARTIFACT_RULE_ENTRY_KEYS = /* @__PURE__ */ new Set(["path", "read", "write"]), SAFE_ARTIFACT_RULE_PATH_RE = /^(?:[A-Za-z0-9_.~:@+-]+|\{self\})(?:\/(?:[A-Za-z0-9_.~:@+-]+|\{self\}))*$/, SAFE_ARTIFACT_RULE_PERMS = /* @__PURE__ */ new Set([
+  "view",
+  "interact",
+  "admin",
+  "owner"
+]), SAFE_ARTIFACT_USER_CAP_KEYS = /* @__PURE__ */ new Set(["scopes"]), SAFE_ARTIFACT_USER_SCOPE_RE = /^[a-z][a-z0-9_-]{0,31}$/;
+function isValidArtifactCapabilityRules(val) {
+  if (!Array.isArray(val)) return !1;
+  for (let rule of val) {
+    if (!isPlainObject(rule)) return !1;
+    for (let rk of Object.keys(rule))
+      if (!SAFE_ARTIFACT_RULE_ENTRY_KEYS.has(rk)) return !1;
+    if (!hasOwn(rule, "path") || typeof rule.path != "string" || rule.path !== "" && !SAFE_ARTIFACT_RULE_PATH_RE.test(rule.path) || hasOwn(rule, "read") && rule.read !== void 0 && (typeof rule.read != "string" || !SAFE_ARTIFACT_RULE_PERMS.has(rule.read)) || hasOwn(rule, "write") && rule.write !== void 0 && (typeof rule.write != "string" || !SAFE_ARTIFACT_RULE_PERMS.has(rule.write)))
+      return !1;
+  }
+  return !0;
+}
+function isValidArtifactCapabilityEntry(capKey, capVal) {
+  if (!SAFE_ARTIFACT_CAPABILITY_KEYS.has(capKey) || !isPlainObject(capVal)) return !1;
+  if (capKey === "mcp") {
+    for (let mk of Object.keys(capVal))
+      if (!SAFE_ARTIFACT_MCP_CAP_KEYS.has(mk)) return !1;
+    if (hasOwn(capVal, "dynamic") && capVal.dynamic !== void 0 && typeof capVal.dynamic != "boolean")
+      return !1;
+    if (hasOwn(capVal, "servers") && capVal.servers !== void 0) {
+      if (!Array.isArray(capVal.servers) || capVal.servers.length > MAX_ARTIFACT_MCP_SERVERS || capVal.servers.length === 0 && capVal.dynamic !== !0)
+        return !1;
+      for (let srv of capVal.servers) {
+        if (!isPlainObject(srv)) return !1;
+        for (let sk of Object.keys(srv))
+          if (!SAFE_ARTIFACT_MCP_SERVER_KEYS.has(sk)) return !1;
+        if (!hasOwn(srv, "server") || typeof srv.server != "string" || srv.server.length === 0 || srv.server.length > 128 || !hasOwn(srv, "tools") || !Array.isArray(srv.tools) || srv.tools.length === 0 || srv.tools.length > MAX_ARTIFACT_MCP_TOOLS || !srv.tools.every((t) => typeof t == "string" && SAFE_ARTIFACT_MCP_TOOL_RE.test(t)))
+          return !1;
+      }
+    }
+    return !0;
+  }
+  if (capKey === "user") {
+    for (let uk of Object.keys(capVal))
+      if (!SAFE_ARTIFACT_USER_CAP_KEYS.has(uk)) return !1;
+    return !(hasOwn(capVal, "scopes") && capVal.scopes !== void 0 && (!Array.isArray(capVal.scopes) || !capVal.scopes.every((s) => typeof s == "string" && SAFE_ARTIFACT_USER_SCOPE_RE.test(s))));
+  }
+  if (SAFE_ARTIFACT_RULE_CAPABILITY_KEYS.has(capKey)) {
+    for (let dk of Object.keys(capVal))
+      if (!SAFE_ARTIFACT_RULE_OBJECT_KEYS.has(dk)) return !1;
+    return !(hasOwn(capVal, "rules") && capVal.rules !== void 0 && !isValidArtifactCapabilityRules(capVal.rules) || hasOwn(capVal, "wake") && capVal.wake !== void 0 && (!Array.isArray(capVal.wake) || !capVal.wake.every((w) => typeof w == "string" && SAFE_ARTIFACT_RULE_PATH_RE.test(w))));
+  }
+  for (let fk of Object.keys(capVal)) {
+    if (!SAFE_ARTIFACT_USER_SCOPE_RE.test(fk)) return !1;
+    let fv = capVal[fk];
+    if (fv !== null && typeof fv != "string" && typeof fv != "boolean" && !isFiniteNumber(fv))
+      return !1;
+  }
+  return !0;
+}
+function isValidArtifactShare(val) {
+  if (!isPlainObject(val)) return !1;
+  for (let k of Object.keys(val))
+    if (!SAFE_ARTIFACT_SHARE_KEYS.has(k)) return !1;
+  if (!hasOwn(val, "mode") || typeof val.mode != "string" || !hasOwn(val, "is_shared_live") || typeof val.is_shared_live != "boolean" || !hasOwn(val, "probed") || typeof val.probed != "boolean" || !hasOwn(val, "probe_current_account") || typeof val.probe_current_account != "boolean" || !hasOwn(val, "grant_observed") || typeof val.grant_observed != "boolean" || hasOwn(val, "role") && val.role !== void 0 && typeof val.role != "string" || hasOwn(val, "artifact_kind") && val.artifact_kind !== void 0 && typeof val.artifact_kind != "string" || hasOwn(val, "type_lock") && val.type_lock !== void 0 && typeof val.type_lock != "boolean")
+    return !1;
+  for (let tk of SAFE_ARTIFACT_SHARE_TRUE_LITERAL_KEYS)
+    if (hasOwn(val, tk) && val[tk] !== void 0 && val[tk] !== !0) return !1;
+  if (hasOwn(val, "live_paths") && val.live_paths !== void 0 && !isStringArray(val.live_paths))
+    return !1;
+  if (hasOwn(val, "capabilities") && val.capabilities !== void 0) {
+    if (!isPlainObject(val.capabilities) || Buffer.byteLength(JSON.stringify(val.capabilities), "utf8") > MAX_ARTIFACT_CAPABILITIES_BYTES)
+      return !1;
+    for (let capKey of Object.keys(val.capabilities))
+      if (!isValidArtifactCapabilityEntry(capKey, val.capabilities[capKey]))
+        return !1;
+  }
+  return !0;
+}
+function isValidArtifacts(val) {
+  if (!isPlainObject(val)) return !1;
+  for (let artk of Object.keys(val))
+    if (!SAFE_ARTIFACTS_KEYS.has(artk)) return !1;
+  if (!hasOwn(val, "by_slug") || !isPlainObject(val.by_slug)) return !1;
+  for (let slugKey of Object.keys(val.by_slug)) {
+    let slugEntry = val.by_slug[slugKey];
+    if (!isPlainObject(slugEntry)) return !1;
+    for (let sek of Object.keys(slugEntry))
+      if (!SAFE_ARTIFACT_SLUG_ENTRY_KEYS.has(sek)) return !1;
+    if (hasOwn(slugEntry, "share") && slugEntry.share !== void 0 && !isValidArtifactShare(slugEntry.share) || hasOwn(slugEntry, "attested") && slugEntry.attested !== void 0 && typeof slugEntry.attested != "string" || hasOwn(slugEntry, "notice_pending") && slugEntry.notice_pending !== void 0 && slugEntry.notice_pending !== !0 || hasOwn(slugEntry, "published_env") && slugEntry.published_env !== void 0 && (typeof slugEntry.published_env != "string" || !SAFE_ARTIFACT_ENV_VALUES.has(slugEntry.published_env)))
+      return !1;
+    if (hasOwn(slugEntry, "watch") && slugEntry.watch !== void 0) {
+      if (!isPlainObject(slugEntry.watch)) return !1;
+      for (let wk of Object.keys(slugEntry.watch))
+        if (!SAFE_ARTIFACT_WATCH_KEYS.has(wk) || slugEntry.watch[wk] !== void 0 && slugEntry.watch[wk] !== !0) return !1;
+    }
+  }
+  if (!hasOwn(val, "by_path") || !isPlainObject(val.by_path)) return !1;
+  for (let pathKey of Object.keys(val.by_path)) {
+    let pathEntry = val.by_path[pathKey];
+    if (!isPlainObject(pathEntry)) return !1;
+    for (let pek of Object.keys(pathEntry))
+      if (!SAFE_ARTIFACT_PATH_ENTRY_KEYS.has(pek)) return !1;
+    if (hasOwn(pathEntry, "slug") && pathEntry.slug !== void 0 && typeof pathEntry.slug != "string" || hasOwn(pathEntry, "thumbnail_named") && pathEntry.thumbnail_named !== void 0 && !isStringArray(pathEntry.thumbnail_named))
+      return !1;
+  }
+  if (!hasOwn(val, "live_docs") || !Array.isArray(val.live_docs)) return !1;
+  for (let doc of val.live_docs) {
+    if (!isPlainObject(doc)) return !1;
+    for (let dk of Object.keys(doc))
+      if (!SAFE_ARTIFACT_LIVE_DOC_KEYS.has(dk)) return !1;
+    if (!hasOwn(doc, "slug") || typeof doc.slug != "string" || !hasOwn(doc, "live_path") || typeof doc.live_path != "string" || !hasOwn(doc, "working_copy") || typeof doc.working_copy != "string")
+      return !1;
+  }
+  if (!hasOwn(val, "room_armed") || !isStringArray(val.room_armed) || !hasOwn(val, "type_reads") || !isPlainObject(val.type_reads)) return !1;
+  for (let trKey of Object.keys(val.type_reads)) {
+    let trEntry = val.type_reads[trKey];
+    if (!isPlainObject(trEntry)) return !1;
+    for (let trk of Object.keys(trEntry))
+      if (!SAFE_ARTIFACT_TYPE_READ_KEYS.has(trk)) return !1;
+    if (!hasOwn(trEntry, "declares_room") || typeof trEntry.declares_room != "boolean")
+      return !1;
+  }
+  if (hasOwn(val, "last_publish") && val.last_publish !== void 0) {
+    let lp = val.last_publish;
+    if (!isPlainObject(lp)) return !1;
+    for (let lpk of Object.keys(lp))
+      if (!SAFE_ARTIFACT_LAST_PUBLISH_KEYS.has(lpk)) return !1;
+    if (!hasOwn(lp, "slug") || typeof lp.slug != "string" || !hasOwn(lp, "env") || typeof lp.env != "string" || !SAFE_ARTIFACT_ENV_VALUES.has(lp.env))
+      return !1;
+  }
+  if (!hasOwn(val, "session") || !isPlainObject(val.session)) return !1;
+  let sess = val.session;
+  for (let sk of Object.keys(sess))
+    if (!SAFE_ARTIFACT_SESSION_KEYS.has(sk)) return !1;
+  if (!hasOwn(sess, "frame_env") || typeof sess.frame_env != "string" || !SAFE_ARTIFACT_ENV_VALUES.has(sess.frame_env) || !hasOwn(sess, "viewer_origin") || typeof sess.viewer_origin != "string" || hasOwn(sess, "dev_viewer_origin") && sess.dev_viewer_origin !== void 0 && typeof sess.dev_viewer_origin != "string")
+    return !1;
+  for (let reqBool of SAFE_ARTIFACT_SESSION_REQUIRED_BOOLEAN_KEYS)
+    if (!hasOwn(sess, reqBool) || typeof sess[reqBool] != "boolean") return !1;
+  for (let optBool of SAFE_ARTIFACT_SESSION_OPTIONAL_BOOLEAN_KEYS)
+    if (hasOwn(sess, optBool) && sess[optBool] !== void 0 && typeof sess[optBool] != "boolean")
+      return !1;
+  return !(hasOwn(sess, "inherited_type_grant") && sess.inherited_type_grant !== void 0 && sess.inherited_type_grant !== !0 || hasOwn(sess, "watch_rail") && sess.watch_rail !== void 0 && (typeof sess.watch_rail != "string" || !SAFE_ARTIFACT_WATCH_RAIL_VALUES.has(sess.watch_rail)) || !hasOwn(sess, "scratchpad_dir") || sess.scratchpad_dir !== null && typeof sess.scratchpad_dir != "string" || hasOwn(sess, "tool_results_dir") && sess.tool_results_dir !== void 0 && typeof sess.tool_results_dir != "string" || hasOwn(val, "truncated") && val.truncated !== void 0 && typeof val.truncated != "boolean");
+}
+function validateCanonicalSafeguards(safeguards) {
+  if (!Array.isArray(safeguards) || safeguards.length > MAX_SAFEGUARDS_ENTRIES)
+    throw new CanonicalRejectError("safeguards is not a canonical dangerous_tool_use array");
+  for (let entry5 of safeguards) {
+    if (!isPlainObject(entry5))
+      throw new CanonicalRejectError("safeguards entry is not a plain object");
+    for (let k of Object.keys(entry5))
+      if (!SAFE_SAFEGUARD_ENTRY_KEYS.has(k))
+        throw new CanonicalRejectError("safeguards entry contains unsupported key");
+    if (!hasOwn(entry5, "type") || entry5.type !== "dangerous_tool_use")
+      throw new CanonicalRejectError("safeguards entry type is not dangerous_tool_use");
+    if (hasOwn(entry5, "classifier_context") && entry5.classifier_context !== void 0) {
+      let ctx = entry5.classifier_context;
+      if (!isPlainObject(ctx))
+        throw new CanonicalRejectError("safeguards classifier_context is not a plain object");
+      for (let ck of Object.keys(ctx))
+        if (!SAFE_CLASSIFIER_CONTEXT_KEYS.has(ck))
+          throw new CanonicalRejectError("safeguards classifier_context contains unsupported key");
+      if (hasOwn(ctx, "v") && ctx.v !== void 0 && !isFiniteNumber(ctx.v))
+        throw new CanonicalRejectError("safeguards classifier_context.v is not a finite number");
+      for (let sk of CLASSIFIER_STRING_KEYS)
+        if (hasOwn(ctx, sk) && ctx[sk] !== void 0 && typeof ctx[sk] != "string")
+          throw new CanonicalRejectError("safeguards classifier_context string field is invalid");
+      for (let bk of CLASSIFIER_BOOLEAN_KEYS)
+        if (hasOwn(ctx, bk) && ctx[bk] !== void 0 && typeof ctx[bk] != "boolean")
+          throw new CanonicalRejectError("safeguards classifier_context boolean field is invalid");
+      if (hasOwn(ctx, "user_identity") && ctx.user_identity !== void 0 && ctx.user_identity !== null && typeof ctx.user_identity != "string")
+        throw new CanonicalRejectError("safeguards classifier_context.user_identity is invalid");
+      if (hasOwn(ctx, "rule_roots") && ctx.rule_roots !== void 0) {
+        if (!isPlainObject(ctx.rule_roots))
+          throw new CanonicalRejectError("safeguards classifier_context.rule_roots is invalid");
+        for (let rk of Object.keys(ctx.rule_roots)) {
+          let rv = ctx.rule_roots[rk];
+          if (!SAFE_RULE_ROOT_KEYS.has(rk) || rv !== null && typeof rv != "string")
+            throw new CanonicalRejectError("safeguards classifier_context.rule_roots is invalid");
+        }
+      }
+      if (hasOwn(ctx, "trusted_directories") && ctx.trusted_directories !== void 0) {
+        if (!isPlainObject(ctx.trusted_directories))
+          throw new CanonicalRejectError("safeguards classifier_context.trusted_directories is invalid");
+        let td = ctx.trusted_directories;
+        for (let tk of Object.keys(td))
+          if (!SAFE_TRUSTED_DIRECTORIES_KEYS.has(tk))
+            throw new CanonicalRejectError("safeguards classifier_context.trusted_directories is invalid");
+        if (hasOwn(td, "primary") && td.primary !== void 0 && td.primary !== null && !isValidTrustedDirEntry(td.primary))
+          throw new CanonicalRejectError("safeguards classifier_context.trusted_directories is invalid");
+        if (hasOwn(td, "additional") && td.additional !== void 0 && (!Array.isArray(td.additional) || !td.additional.every((item2) => typeof item2 == "string" || isValidTrustedDirEntry(item2))))
+          throw new CanonicalRejectError("safeguards classifier_context.trusted_directories is invalid");
+        if (hasOwn(td, "network") && td.network !== void 0 && !isStringArray(td.network))
+          throw new CanonicalRejectError("safeguards classifier_context.trusted_directories is invalid");
+        if (hasOwn(td, "block_reads_outside_working_directories") && td.block_reads_outside_working_directories !== void 0 && typeof td.block_reads_outside_working_directories != "boolean")
+          throw new CanonicalRejectError("safeguards classifier_context.trusted_directories is invalid");
+      }
+      if (hasOwn(ctx, "rules") && ctx.rules !== void 0) {
+        if (!isPlainObject(ctx.rules))
+          throw new CanonicalRejectError("safeguards classifier_context.rules is invalid");
+        for (let rlk of Object.keys(ctx.rules)) {
+          let rlv = ctx.rules[rlk];
+          if (!SAFE_RULES_KEYS.has(rlk) || !Array.isArray(rlv))
+            throw new CanonicalRejectError("safeguards classifier_context.rules is invalid");
+          for (let item2 of rlv) {
+            if (!isPlainObject(item2))
+              throw new CanonicalRejectError("safeguards classifier_context.rules is invalid");
+            for (let ik of Object.keys(item2))
+              if (!SAFE_RULE_ITEM_KEYS.has(ik))
+                throw new CanonicalRejectError("safeguards classifier_context.rules is invalid");
+            if (!hasOwn(item2, "rule") || typeof item2.rule != "string" || !hasOwn(item2, "source") || typeof item2.source != "string")
+              throw new CanonicalRejectError("safeguards classifier_context.rules is invalid");
+            if (hasOwn(item2, "canonical") && item2.canonical !== void 0 && typeof item2.canonical != "string")
+              throw new CanonicalRejectError("safeguards classifier_context.rules is invalid");
+            if (hasOwn(item2, "root") && item2.root !== void 0 && item2.root !== null && typeof item2.root != "string")
+              throw new CanonicalRejectError("safeguards classifier_context.rules is invalid");
+            if (hasOwn(item2, "pattern") && item2.pattern !== void 0 && typeof item2.pattern != "string")
+              throw new CanonicalRejectError("safeguards classifier_context.rules is invalid");
+          }
+        }
+      }
+      if (hasOwn(ctx, "dropped") && ctx.dropped !== void 0) {
+        if (!isPlainObject(ctx.dropped))
+          throw new CanonicalRejectError("safeguards classifier_context.dropped is invalid");
+        for (let dk of Object.keys(ctx.dropped)) {
+          let dv = ctx.dropped[dk];
+          if (!SAFE_DROPPED_KEYS.has(dk) || !isFiniteNumber(dv))
+            throw new CanonicalRejectError("safeguards classifier_context.dropped is invalid");
+        }
+      }
+      if (hasOwn(ctx, "auto_mode") && ctx.auto_mode !== void 0) {
+        if (!isPlainObject(ctx.auto_mode))
+          throw new CanonicalRejectError("safeguards classifier_context.auto_mode is invalid");
+        for (let ak of Object.keys(ctx.auto_mode))
+          if (!SAFE_AUTO_MODE_KEYS.has(ak) || !isStringArray(ctx.auto_mode[ak]))
+            throw new CanonicalRejectError("safeguards classifier_context.auto_mode is invalid");
+      }
+      if (hasOwn(ctx, "git_state") && ctx.git_state !== void 0 && ctx.git_state !== null && !isValidGitState(ctx.git_state))
+        throw new CanonicalRejectError("safeguards classifier_context.git_state is invalid");
+      if (hasOwn(ctx, "chrome_navigation") && ctx.chrome_navigation !== void 0 && !isValidChromeNavigation(ctx.chrome_navigation))
+        throw new CanonicalRejectError("safeguards classifier_context.chrome_navigation is invalid");
+      if (hasOwn(ctx, "prior_turn_context") && ctx.prior_turn_context !== void 0) {
+        if (!Array.isArray(ctx.prior_turn_context))
+          throw new CanonicalRejectError("safeguards classifier_context.prior_turn_context is invalid");
+        for (let pt of ctx.prior_turn_context) {
+          if (!isPlainObject(pt))
+            throw new CanonicalRejectError("safeguards classifier_context.prior_turn_context is invalid");
+          for (let ptk of Object.keys(pt))
+            if (!SAFE_PRIOR_TURN_ENTRY_KEYS.has(ptk))
+              throw new CanonicalRejectError("safeguards classifier_context.prior_turn_context is invalid");
+          if (!hasOwn(pt, "tool_use_ids") || !isStringArray(pt.tool_use_ids))
+            throw new CanonicalRejectError("safeguards classifier_context.prior_turn_context is invalid");
+          if (!hasOwn(pt, "context") || !isPlainObject(pt.context))
+            throw new CanonicalRejectError("safeguards classifier_context.prior_turn_context is invalid");
+          for (let icKey of Object.keys(pt.context))
+            if (!SAFE_PRIOR_TURN_INNER_CONTEXT_KEYS.has(icKey))
+              throw new CanonicalRejectError("safeguards classifier_context.prior_turn_context is invalid");
+          if (hasOwn(pt.context, "git_state") && pt.context.git_state !== void 0 && pt.context.git_state !== null && !isValidGitState(pt.context.git_state))
+            throw new CanonicalRejectError("safeguards classifier_context.prior_turn_context is invalid");
+          if (hasOwn(pt.context, "chrome_navigation") && pt.context.chrome_navigation !== void 0 && !isValidChromeNavigation(pt.context.chrome_navigation))
+            throw new CanonicalRejectError("safeguards classifier_context.prior_turn_context is invalid");
+          if (hasOwn(pt.context, "live_cwd") && pt.context.live_cwd !== void 0 && typeof pt.context.live_cwd != "string")
+            throw new CanonicalRejectError("safeguards classifier_context.prior_turn_context is invalid");
+          if (hasOwn(pt.context, "platform") && pt.context.platform !== void 0 && typeof pt.context.platform != "string")
+            throw new CanonicalRejectError("safeguards classifier_context.prior_turn_context is invalid");
+        }
+      }
+      if (hasOwn(ctx, "system_reminders") && ctx.system_reminders !== void 0) {
+        if (!Array.isArray(ctx.system_reminders))
+          throw new CanonicalRejectError("safeguards classifier_context.system_reminders is invalid");
+        for (let sr of ctx.system_reminders) {
+          if (!isPlainObject(sr))
+            throw new CanonicalRejectError("safeguards classifier_context.system_reminders is invalid");
+          for (let srk of Object.keys(sr))
+            if (!SAFE_SYSTEM_REMINDER_KEYS.has(srk))
+              throw new CanonicalRejectError("safeguards classifier_context.system_reminders is invalid");
+          if (!hasOwn(sr, "id") || typeof sr.id != "string" || !hasOwn(sr, "provenance") || typeof sr.provenance != "string")
+            throw new CanonicalRejectError("safeguards classifier_context.system_reminders is invalid");
+          if (hasOwn(sr, "author") && sr.author !== void 0 && typeof sr.author != "string")
+            throw new CanonicalRejectError("safeguards classifier_context.system_reminders is invalid");
+          if (hasOwn(sr, "written") && sr.written !== void 0 && typeof sr.written != "string")
+            throw new CanonicalRejectError("safeguards classifier_context.system_reminders is invalid");
+        }
+      }
+      if (hasOwn(ctx, "artifacts") && ctx.artifacts !== void 0 && !isValidArtifacts(ctx.artifacts))
+        throw new CanonicalRejectError("safeguards classifier_context.artifacts is invalid");
+      if (hasOwn(ctx, "shed") && ctx.shed !== void 0 && !isStringArray(ctx.shed))
+        throw new CanonicalRejectError("safeguards classifier_context.shed is invalid");
+    }
+  }
+}
 function canonicalBetaHeader(provider, agentHeaders) {
   let cfg = getProviderConfig(provider);
   if (!cfg.betaHeaderName) return {};
@@ -86697,6 +87480,7 @@ function buildCanonicalRequest(input) {
     if (typeof model != "string" || !CANONICAL_MODEL_ID.test(model))
       throw new CanonicalRejectError("model is not a canonical model id");
   }
+  provider === "anthropic" && hasOwn(body, "safeguards") && validateCanonicalSafeguards(body.safeguards);
   let modelCallId = (0, import_node_crypto35.randomUUID)(), sha = requestSha256(body), headers = {
     ...cfg.synthesizedHeaders,
     ...canonicalBetaHeader(provider, input.agentHeaders)
@@ -87220,7 +88004,10 @@ var LocalModelGatewayBroker = class {
       });
     } catch (err) {
       if (err instanceof CanonicalRejectError)
-        return { status: 400, body: { error: err.reason } };
+        return logger.warn("[broker] rejected non-canonical model request", {
+          provider,
+          reason: err.reason
+        }), { status: 400, body: { error: err.reason } };
       throw err;
     }
     let { modelCallId, requestSha256: reqSha } = canonical, selfSecrets = [