@quantiya/codevibe-claude-plugin 2.0.69 → 2.0.71

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

@@ -11572,6 +11572,8 @@ var AppSyncClient = class _AppSyncClient {
       throw [
         mutations.createEvent,
         mutations.updateEventStatus,
+        mutations.createEventV2,
+        mutations.updateEventV2,
         mutations.recordWorkspaceOutcomeV2,
         mutations.reportSecurityPostureV2,
         queries.listEvents,
@@ -11724,7 +11726,7 @@ var AppSyncClient = class _AppSyncClient {
     return !this.authenticated || this.currentUserId !== userId || this.tokens?.userId !== userId || value?.userId !== userId || value.state.environment !== this.environment || !Number.isSafeInteger(now) || value.state.observedAtEpochMs > now + SYNC_STATE_CLOCK_SKEW_MS || now >= value.state.validUntilEpochMs ? null : value.state;
   }
   /** Existing socket maintenance recovers idle status after its cloud cache
-   * expires. This is display-only; admissions never use the cached result. */
+   * expires. Cached observations never grant cloud mutation authority. */
   async refreshCompanionSyncDisplayOnMaintenance(userId, signal) {
     this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal), !this.companionSyncStatusSnapshot(userId) && (await this.getCompanionSyncState(signal), this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal));
   }
@@ -11918,7 +11920,8 @@ var AppSyncClient = class _AppSyncClient {
       send: (action, input, signal) => (this.assertSyncAccount(userId), this.mutateDesktopSyncEvent(action, input, signal)),
       isQuotaDenial: (error) => error instanceof AppSyncGraphQLError && error.errorType === "SYNC_QUOTA_EXHAUSTED",
       omitNewPayload: async (signal) => {
-        let state = await this.getCompanionSyncState(signal);
+        this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal);
+        let observed = this.companionSyncStatusSnapshot(userId), state = observed?.mode === "SHADOW" ? observed : await this.getCompanionSyncState(signal);
         if (this.assertSyncAccount(userId), _AppSyncClient.throwIfAborted(signal), state.protocol !== "SYNC_V2") throw new SyncEventClientError("SYNC_PRODUCER_FROZEN");
         return state.usage?.syncState === "PAUSED";
       }
@@ -76689,7 +76692,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 {
@@ -76705,7 +76708,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,
@@ -86635,7 +86641,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",
@@ -86811,6 +86827,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 {};
@@ -86831,6 +87483,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)
@@ -87354,7 +88007,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 = [