oh-my-opencode 5.1.45 → 5.1.46

package/dist/index.js

@@ -11833,7 +11833,7 @@ var init_member_parser = __esm(() => {
 });
 
 // packages/team-core/src/types.ts
-import * as z56 from "zod";
+import * as z55 from "zod";
 var MESSAGE_KINDS, TASK_STATUSES, RUNTIME_STATUSES, MemberBaseSchema, CategoryMemberSchema, SubagentMemberSchema, MemberSchema, TeamReferenceSchema, MISSING_TEAM_LEAD_MESSAGE = "leadAgentId required (or write a `lead: {...}` field, or mark one member with `isLead: true`)", TeamSpecSchema, MessageSchema, TaskSchema, RuntimeStateMemberModelSchema, RuntimeStateMemberSchema, RuntimeBoundsSchema, ShutdownRequestSchema, RuntimeStateTmuxLayoutSchema, RuntimeStateSchema, AGENT_ELIGIBILITY_REGISTRY, parseMemberBase;
 var init_types2 = __esm(() => {
   init_member_parser();
@@ -11854,40 +11854,40 @@ var init_types2 = __esm(() => {
     "failed",
     "orphaned"
   ];
-  MemberBaseSchema = z56.object({
-    name: z56.string().min(1).regex(/^[a-z0-9-]+$/),
-    cwd: z56.string().optional(),
-    worktreePath: z56.string().optional(),
-    task_summary: z56.string().max(80).optional(),
-    subscriptions: z56.array(z56.string()).optional(),
-    backendType: z56.enum(["in-process", "tmux"]).default("in-process"),
-    color: z56.string().optional(),
-    isActive: z56.boolean().default(true)
+  MemberBaseSchema = z55.object({
+    name: z55.string().min(1).regex(/^[a-z0-9-]+$/),
+    cwd: z55.string().optional(),
+    worktreePath: z55.string().optional(),
+    task_summary: z55.string().max(80).optional(),
+    subscriptions: z55.array(z55.string()).optional(),
+    backendType: z55.enum(["in-process", "tmux"]).default("in-process"),
+    color: z55.string().optional(),
+    isActive: z55.boolean().default(true)
   }).strict();
   CategoryMemberSchema = MemberBaseSchema.extend({
-    kind: z56.literal("category"),
-    category: z56.string().min(1),
-    prompt: z56.string().min(1)
+    kind: z55.literal("category"),
+    category: z55.string().min(1),
+    prompt: z55.string().min(1)
   });
   SubagentMemberSchema = MemberBaseSchema.extend({
-    kind: z56.literal("subagent_type"),
-    subagent_type: z56.string().min(1),
-    prompt: z56.string().optional()
+    kind: z55.literal("subagent_type"),
+    subagent_type: z55.string().min(1),
+    prompt: z55.string().optional()
   });
-  MemberSchema = z56.discriminatedUnion("kind", [CategoryMemberSchema, SubagentMemberSchema]);
-  TeamReferenceSchema = z56.object({
-    path: z56.string(),
-    description: z56.string().optional()
+  MemberSchema = z55.discriminatedUnion("kind", [CategoryMemberSchema, SubagentMemberSchema]);
+  TeamReferenceSchema = z55.object({
+    path: z55.string(),
+    description: z55.string().optional()
   }).strict();
-  TeamSpecSchema = z56.object({
-    version: z56.literal(1).default(1),
-    name: z56.string().min(1).regex(/^[a-z0-9-]+$/),
-    description: z56.string().optional(),
-    createdAt: z56.number().int().positive().default(() => Date.now()),
-    leadAgentId: z56.string().optional(),
-    teamAllowedPaths: z56.array(z56.string()).optional(),
-    sessionPermission: z56.string().optional(),
-    members: z56.array(MemberSchema).min(1).max(8)
+  TeamSpecSchema = z55.object({
+    version: z55.literal(1).default(1),
+    name: z55.string().min(1).regex(/^[a-z0-9-]+$/),
+    description: z55.string().optional(),
+    createdAt: z55.number().int().positive().default(() => Date.now()),
+    leadAgentId: z55.string().optional(),
+    teamAllowedPaths: z55.array(z55.string()).optional(),
+    sessionPermission: z55.string().optional(),
+    members: z55.array(MemberSchema).min(1).max(8)
   }).superRefine((teamSpec, ctx) => {
     if (teamSpec.leadAgentId === undefined && teamSpec.members.length > 1) {
       ctx.addIssue({
@@ -11909,95 +11909,95 @@ var init_types2 = __esm(() => {
       leadAgentId: firstMember.name
     };
   });
-  MessageSchema = z56.object({
-    version: z56.literal(1),
-    messageId: z56.string().uuid(),
-    from: z56.string(),
-    to: z56.string(),
-    kind: z56.enum(MESSAGE_KINDS),
-    body: z56.string().max(32 * 1024),
-    summary: z56.string().optional(),
-    references: z56.array(TeamReferenceSchema).optional(),
-    timestamp: z56.number().int().positive(),
-    correlationId: z56.string().uuid().optional(),
-    color: z56.string().optional()
+  MessageSchema = z55.object({
+    version: z55.literal(1),
+    messageId: z55.string().uuid(),
+    from: z55.string(),
+    to: z55.string(),
+    kind: z55.enum(MESSAGE_KINDS),
+    body: z55.string().max(32 * 1024),
+    summary: z55.string().optional(),
+    references: z55.array(TeamReferenceSchema).optional(),
+    timestamp: z55.number().int().positive(),
+    correlationId: z55.string().uuid().optional(),
+    color: z55.string().optional()
   });
-  TaskSchema = z56.object({
-    version: z56.literal(1),
-    id: z56.string(),
-    subject: z56.string(),
-    description: z56.string(),
-    activeForm: z56.string().optional(),
-    status: z56.enum(TASK_STATUSES),
-    owner: z56.string().optional(),
-    blocks: z56.array(z56.string()).default([]),
-    blockedBy: z56.array(z56.string()).default([]),
-    metadata: z56.record(z56.string(), z56.unknown()).optional(),
-    createdAt: z56.number().int().positive(),
-    updatedAt: z56.number().int().positive(),
-    claimedAt: z56.number().int().positive().optional()
+  TaskSchema = z55.object({
+    version: z55.literal(1),
+    id: z55.string(),
+    subject: z55.string(),
+    description: z55.string(),
+    activeForm: z55.string().optional(),
+    status: z55.enum(TASK_STATUSES),
+    owner: z55.string().optional(),
+    blocks: z55.array(z55.string()).default([]),
+    blockedBy: z55.array(z55.string()).default([]),
+    metadata: z55.record(z55.string(), z55.unknown()).optional(),
+    createdAt: z55.number().int().positive(),
+    updatedAt: z55.number().int().positive(),
+    claimedAt: z55.number().int().positive().optional()
   });
-  RuntimeStateMemberModelSchema = z56.object({
-    providerID: z56.string(),
-    modelID: z56.string(),
-    variant: z56.string().optional(),
-    reasoningEffort: z56.string().optional(),
-    temperature: z56.number().optional(),
-    top_p: z56.number().optional(),
-    maxTokens: z56.number().optional(),
-    thinking: z56.object({
-      type: z56.enum(["enabled", "disabled"]),
-      budgetTokens: z56.number().int().positive().optional()
+  RuntimeStateMemberModelSchema = z55.object({
+    providerID: z55.string(),
+    modelID: z55.string(),
+    variant: z55.string().optional(),
+    reasoningEffort: z55.string().optional(),
+    temperature: z55.number().optional(),
+    top_p: z55.number().optional(),
+    maxTokens: z55.number().optional(),
+    thinking: z55.object({
+      type: z55.enum(["enabled", "disabled"]),
+      budgetTokens: z55.number().int().positive().optional()
     }).optional()
   }).strict();
-  RuntimeStateMemberSchema = z56.object({
-    name: z56.string(),
-    sessionId: z56.string().optional(),
-    tmuxPaneId: z56.string().optional(),
-    tmuxGridPaneId: z56.string().optional(),
-    agentType: z56.enum(["leader", "general-purpose"]),
-    subagent_type: z56.string().optional(),
-    category: z56.string().optional(),
+  RuntimeStateMemberSchema = z55.object({
+    name: z55.string(),
+    sessionId: z55.string().optional(),
+    tmuxPaneId: z55.string().optional(),
+    tmuxGridPaneId: z55.string().optional(),
+    agentType: z55.enum(["leader", "general-purpose"]),
+    subagent_type: z55.string().optional(),
+    category: z55.string().optional(),
     model: RuntimeStateMemberModelSchema.optional(),
-    status: z56.enum(["pending", "running", "idle", "errored", "completed", "shutdown_approved"]),
-    color: z56.string().optional(),
-    worktreePath: z56.string().optional(),
-    lastInjectedTurnMarker: z56.string().optional(),
-    pendingInjectedMessageIds: z56.array(z56.string()).default([])
+    status: z55.enum(["pending", "running", "idle", "errored", "completed", "shutdown_approved"]),
+    color: z55.string().optional(),
+    worktreePath: z55.string().optional(),
+    lastInjectedTurnMarker: z55.string().optional(),
+    pendingInjectedMessageIds: z55.array(z55.string()).default([])
   }).strict();
-  RuntimeBoundsSchema = z56.object({
-    maxMembers: z56.number().int().default(8),
-    maxParallelMembers: z56.number().int().default(4),
-    maxMessagesPerRun: z56.number().int().default(1e4),
-    maxWallClockMinutes: z56.number().int().default(120),
-    maxMemberTurns: z56.number().int().default(500)
+  RuntimeBoundsSchema = z55.object({
+    maxMembers: z55.number().int().default(8),
+    maxParallelMembers: z55.number().int().default(4),
+    maxMessagesPerRun: z55.number().int().default(1e4),
+    maxWallClockMinutes: z55.number().int().default(120),
+    maxMemberTurns: z55.number().int().default(500)
   }).strict();
-  ShutdownRequestSchema = z56.object({
-    memberId: z56.string(),
-    requesterName: z56.string(),
-    requestedAt: z56.number().int().positive(),
-    approvedAt: z56.number().int().positive().optional(),
-    rejectedReason: z56.string().optional(),
-    rejectedAt: z56.number().int().positive().optional()
+  ShutdownRequestSchema = z55.object({
+    memberId: z55.string(),
+    requesterName: z55.string(),
+    requestedAt: z55.number().int().positive(),
+    approvedAt: z55.number().int().positive().optional(),
+    rejectedReason: z55.string().optional(),
+    rejectedAt: z55.number().int().positive().optional()
   }).strict();
-  RuntimeStateTmuxLayoutSchema = z56.object({
-    ownedSession: z56.boolean(),
-    targetSessionId: z56.string(),
-    focusWindowId: z56.string().optional(),
-    gridWindowId: z56.string().optional(),
-    paneIds: z56.array(z56.string()).optional()
+  RuntimeStateTmuxLayoutSchema = z55.object({
+    ownedSession: z55.boolean(),
+    targetSessionId: z55.string(),
+    focusWindowId: z55.string().optional(),
+    gridWindowId: z55.string().optional(),
+    paneIds: z55.array(z55.string()).optional()
   }).strict();
-  RuntimeStateSchema = z56.object({
-    version: z56.literal(1),
-    teamRunId: z56.string().uuid(),
-    teamName: z56.string(),
-    specSource: z56.enum(["project", "user"]),
-    createdAt: z56.number().int().positive(),
-    status: z56.enum(RUNTIME_STATUSES),
-    leadSessionId: z56.string().optional(),
+  RuntimeStateSchema = z55.object({
+    version: z55.literal(1),
+    teamRunId: z55.string().uuid(),
+    teamName: z55.string(),
+    specSource: z55.enum(["project", "user"]),
+    createdAt: z55.number().int().positive(),
+    status: z55.enum(RUNTIME_STATUSES),
+    leadSessionId: z55.string().optional(),
     tmuxLayout: RuntimeStateTmuxLayoutSchema.optional(),
-    members: z56.array(RuntimeStateMemberSchema),
-    shutdownRequests: z56.array(ShutdownRequestSchema).default([]),
+    members: z55.array(RuntimeStateMemberSchema),
+    shutdownRequests: z55.array(ShutdownRequestSchema).default([]),
     bounds: RuntimeBoundsSchema
   });
   AGENT_ELIGIBILITY_REGISTRY = {
@@ -12352,7 +12352,7 @@ var init_lock_publish = __esm(() => {
 });
 
 // packages/team-core/src/team-state-store/lock-reclaim.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { unlink as unlink3 } from "fs/promises";
 function delay3(ms) {
   return new Promise((resolve) => {
@@ -12360,7 +12360,7 @@ function delay3(ms) {
   });
 }
 function reclaimGuardPath(lockPath, record) {
-  return `${lockPath}.reclaim-${createHash4("sha256").update(record).digest("hex").slice(0, 16)}`;
+  return `${lockPath}.reclaim-${createHash5("sha256").update(record).digest("hex").slice(0, 16)}`;
 }
 async function unlinkWithRetry(path, deps) {
   const wait = deps.delay ?? delay3;
@@ -86531,7 +86531,7 @@ var OmoCategoryConfigSchema = z4.preprocess((value) => isRecord7(value) ? normal
 var OmoCategoriesConfigSchema = z4.record(z4.string(), OmoCategoryConfigSchema);
 
 // packages/omo-config-core/src/schema/config.ts
-import * as z19 from "zod";
+import * as z18 from "zod";
 
 // packages/omo-config-core/src/schema/computer.ts
 import * as z5 from "zod";
@@ -86608,6 +86608,7 @@ var OmoMemoryReflectionSchema = z9.object({
   merge: z9.enum(["auto", "integration"]).default("auto"),
   category: z9.string().min(1).default("quick"),
   timeout_minutes: z9.number().int().positive().default(15),
+  max_concurrent_runs: z9.number().int().positive().default(1),
   sandbox: z9.enum(["auto", "required", "off"]).default("auto")
 }).strict();
 var OmoMemorySyncSchema = z9.object({
@@ -86679,6 +86680,7 @@ var OmoMemoryReflectionLayerSchema = z9.object({
   merge: z9.enum(["auto", "integration"]).optional(),
   category: z9.string().min(1).optional(),
   timeout_minutes: z9.number().int().positive().optional(),
+  max_concurrent_runs: z9.number().int().positive().optional(),
   sandbox: z9.enum(["auto", "required", "off"]).optional()
 }).strict();
 var OmoMemorySyncLayerSchema = z9.object({
@@ -86743,7 +86745,7 @@ var OmoMemoryProjectionLayerSchema = z9.object({
 var OmoMemoryAgentOverridesSchema = z9.object({
   enabled: z9.boolean().optional(),
   agent: z9.string().min(1).optional(),
-  reflection: OmoMemoryReflectionLayerSchema.optional(),
+  reflection: OmoMemoryReflectionLayerSchema.omit({ max_concurrent_runs: true }).optional(),
   nudge: OmoMemoryNudgeLayerSchema.optional(),
   facts: OmoMemoryFactsLayerSchema.optional(),
   dream: OmoMemoryDreamLayerSchema.optional(),
@@ -86768,6 +86770,7 @@ var OmoMemorySettingsSchema = z9.object({
     merge: "auto",
     category: "quick",
     timeout_minutes: 15,
+    max_concurrent_runs: 1,
     sandbox: "auto"
   }),
   nudge: OmoMemoryNudgeSchema.default({ enabled: true, every_user_turns: 10 }),
@@ -87118,28 +87121,23 @@ var OmoFormatOnMutationSchema = OmoFormatOnMutationLayerSchema.extend({
   timeoutMs: z16.number().int().positive().default(3000)
 }).strict();
 
-// packages/omo-config-core/src/schema/dori.ts
-import * as z17 from "zod";
-var OmoDoriSectionSchema = z17.record(z17.string(), z17.unknown()).describe("Chat-surface dori settings, owned and validated by a separately installed dori package. omo accepts the key and never reads it.");
-
 // packages/omo-config-core/src/schema/provenance.ts
-import * as z18 from "zod";
-var OmoProvenanceSettingsSchema = z18.object({
-  workspaces: z18.array(z18.object({
-    name: z18.string().trim().min(1).regex(/\S/),
-    git_owners: z18.array(z18.string().trim().min(1).regex(/\S/)).optional(),
-    paths: z18.array(z18.string().trim().min(1).regex(/\S/)).optional()
+import * as z17 from "zod";
+var OmoProvenanceSettingsSchema = z17.object({
+  workspaces: z17.array(z17.object({
+    name: z17.string().trim().min(1).regex(/\S/),
+    git_owners: z17.array(z17.string().trim().min(1).regex(/\S/)).optional(),
+    paths: z17.array(z17.string().trim().min(1).regex(/\S/)).optional()
   }).strict()).optional()
 }).strict();
 
 // packages/omo-config-core/src/schema/config.ts
-var OmoOpenCodeHarnessConfigSchema = z19.record(z19.string(), z19.unknown());
-var OmoDisabledSkillsSchema = z19.array(z19.string());
-var OmoExcludedModelsSchema = z19.array(z19.string());
-var OmoTypedHarnessConfigSchema = z19.object({
+var OmoOpenCodeHarnessConfigSchema = z18.record(z18.string(), z18.unknown());
+var OmoDisabledSkillsSchema = z18.array(z18.string());
+var OmoExcludedModelsSchema = z18.array(z18.string());
+var OmoTypedHarnessConfigSchema = z18.object({
   provenance: OmoProvenanceSettingsSchema.optional(),
   formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
-  dori: OmoDoriSectionSchema.optional(),
   categories: OmoCategoriesConfigSchema.optional(),
   agents: OmoAgentsConfigSchema.optional(),
   git_master: OmoGitMasterSettingsLayerSchema.optional(),
@@ -87147,7 +87145,7 @@ var OmoTypedHarnessConfigSchema = z19.object({
   teams: OmoTeamsConfigLayerSchema.optional(),
   models: OmoModelCatalogLayerSchema.optional(),
   model_profiles: OmoModelProfilesLayerSchema.optional(),
-  model_profile: z19.string().optional(),
+  model_profile: z18.string().optional(),
   memory: OmoMemorySettingsLayerSchema.optional(),
   telemetry: OmoTelemetrySettingsLayerSchema.optional(),
   side_panel: OmoSidePanelSettingsLayerSchema.optional(),
@@ -87155,10 +87153,9 @@ var OmoTypedHarnessConfigSchema = z19.object({
   disabled_skills: OmoDisabledSkillsSchema.optional(),
   exclude_models: OmoExcludedModelsSchema.optional()
 }).strict();
-var OmoConfigProfileSchema = z19.object({
+var OmoConfigProfileSchema = z18.object({
   provenance: OmoProvenanceSettingsSchema.optional(),
   formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
-  dori: OmoDoriSectionSchema.optional(),
   categories: OmoCategoriesConfigSchema.optional(),
   agents: OmoAgentsConfigSchema.optional(),
   git_master: OmoGitMasterSettingsLayerSchema.optional(),
@@ -87166,7 +87163,7 @@ var OmoConfigProfileSchema = z19.object({
   teams: OmoTeamsConfigLayerSchema.optional(),
   models: OmoModelCatalogLayerSchema.optional(),
   model_profiles: OmoModelProfilesLayerSchema.optional(),
-  model_profile: z19.string().optional(),
+  model_profile: z18.string().optional(),
   memory: OmoMemorySettingsLayerSchema.optional(),
   telemetry: OmoTelemetrySettingsLayerSchema.optional(),
   side_panel: OmoSidePanelSettingsLayerSchema.optional(),
@@ -87178,11 +87175,10 @@ var OmoConfigProfileSchema = z19.object({
   "[senpi]": OmoTypedHarnessConfigSchema.optional(),
   "[codex]": OmoTypedHarnessConfigSchema.optional()
 }).strict();
-var OmoConfigSchema = z19.object({
+var OmoConfigSchema = z18.object({
   provenance: OmoProvenanceSettingsSchema.optional(),
   formatOnMutation: OmoFormatOnMutationSchema.optional(),
-  dori: OmoDoriSectionSchema.optional(),
-  $schema: z19.string().optional(),
+  $schema: z18.string().optional(),
   categories: OmoCategoriesConfigSchema.optional(),
   agents: OmoAgentsConfigSchema.optional(),
   git_master: OmoGitMasterSettingsSchema.optional(),
@@ -87190,7 +87186,7 @@ var OmoConfigSchema = z19.object({
   teams: OmoTeamsConfigSchema.optional(),
   models: OmoModelCatalogSchema.optional(),
   model_profiles: OmoModelProfilesSchema.optional(),
-  model_profile: z19.string().optional(),
+  model_profile: z18.string().optional(),
   memory: OmoMemorySettingsSchema.optional(),
   telemetry: OmoTelemetrySettingsSchema.optional(),
   side_panel: OmoSidePanelSettingsSchema.optional(),
@@ -87201,15 +87197,14 @@ var OmoConfigSchema = z19.object({
   "[native]": OmoTypedHarnessConfigSchema.optional(),
   "[senpi]": OmoTypedHarnessConfigSchema.optional(),
   "[codex]": OmoTypedHarnessConfigSchema.optional(),
-  profiles: z19.record(z19.string(), OmoConfigProfileSchema).default({}),
-  _migrations: z19.array(z19.string()).optional(),
-  legacy_migrations: z19.record(z19.string(), z19.unknown()).optional()
+  profiles: z18.record(z18.string(), OmoConfigProfileSchema).default({}),
+  _migrations: z18.array(z18.string()).optional(),
+  legacy_migrations: z18.record(z18.string(), z18.unknown()).optional()
 }).strict();
-var OmoConfigLayerSchema = z19.object({
+var OmoConfigLayerSchema = z18.object({
   provenance: OmoProvenanceSettingsSchema.optional(),
   formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
-  dori: OmoDoriSectionSchema.optional(),
-  $schema: z19.string().optional(),
+  $schema: z18.string().optional(),
   categories: OmoCategoriesConfigSchema.optional(),
   agents: OmoAgentsConfigSchema.optional(),
   git_master: OmoGitMasterSettingsLayerSchema.optional(),
@@ -87217,7 +87212,7 @@ var OmoConfigLayerSchema = z19.object({
   teams: OmoTeamsConfigLayerSchema.optional(),
   models: OmoModelCatalogLayerSchema.optional(),
   model_profiles: OmoModelProfilesLayerSchema.optional(),
-  model_profile: z19.string().optional(),
+  model_profile: z18.string().optional(),
   memory: OmoMemorySettingsLayerSchema.optional(),
   telemetry: OmoTelemetrySettingsLayerSchema.optional(),
   side_panel: OmoSidePanelSettingsLayerSchema.optional(),
@@ -87228,9 +87223,9 @@ var OmoConfigLayerSchema = z19.object({
   "[native]": OmoTypedHarnessConfigSchema.optional(),
   "[senpi]": OmoTypedHarnessConfigSchema.optional(),
   "[codex]": OmoTypedHarnessConfigSchema.optional(),
-  profiles: z19.record(z19.string(), OmoConfigProfileSchema).optional(),
-  _migrations: z19.array(z19.string()).optional(),
-  legacy_migrations: z19.record(z19.string(), z19.unknown()).optional()
+  profiles: z18.record(z18.string(), OmoConfigProfileSchema).optional(),
+  _migrations: z18.array(z18.string()).optional(),
+  legacy_migrations: z18.record(z18.string(), z18.unknown()).optional()
 }).strict();
 
 // packages/omo-config-core/src/schema/legacy-category-names.ts
@@ -87343,51 +87338,6 @@ function hasLegacyHarnessBlocks(document) {
   return canonicalizeLegacyHarnessBlocks(document).renames.length > 0;
 }
 
-// packages/omo-config-core/src/schema/legacy-dori-section.ts
-var HARNESS_BLOCKS = ["[opencode]", "[native]", "[senpi]", "[codex]"];
-function isRecord12(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function migrateLegacyDoriSection(document) {
-  if (!isRecord12(document))
-    return { document: {}, diagnostics: [] };
-  const diagnostics = [];
-  const rename = (container, path) => {
-    const result = { ...container };
-    if (Object.hasOwn(container, "gateway")) {
-      if (Object.hasOwn(container, "dori")) {
-        diagnostics.push(`${[...path, "gateway"].join(".")} removed: dori is already configured`);
-      } else {
-        result.dori = container.gateway;
-        diagnostics.push(`${[...path, "gateway"].join(".")} renamed to dori`);
-      }
-      delete result.gateway;
-    }
-    return result;
-  };
-  const layer = (container, path) => {
-    const result = rename(container, path);
-    for (const key of HARNESS_BLOCKS) {
-      const block = container[key];
-      if (isRecord12(block))
-        result[key] = rename(block, [...path, key]);
-    }
-    return result;
-  };
-  const result = layer(document, []);
-  if (isRecord12(document.profiles)) {
-    const profiles = {};
-    for (const [name, profile] of Object.entries(document.profiles)) {
-      profiles[name] = isRecord12(profile) ? layer(profile, ["profiles", name]) : profile;
-    }
-    result.profiles = profiles;
-  }
-  return { document: result, diagnostics };
-}
-function hasLegacyGatewaySection(document) {
-  return migrateLegacyDoriSection(document).diagnostics.length > 0;
-}
-
 // packages/omo-config-core/src/loader/types.ts
 import { existsSync as existsSync29, lstatSync as lstatSync2, readFileSync as readFileSync20, realpathSync as realpathSync7 } from "fs";
 var MERGED_OMO_CONFIG_PATH = "(merged omo config)";
@@ -87488,6 +87438,9 @@ function collectUnionedList(key, options) {
 // packages/omo-config-core/src/loader/loader.ts
 init_main();
 
+// packages/omo-config-core/src/loader/layer-validation.ts
+import { createHash as createHash3 } from "crypto";
+
 // packages/omo-config-core/src/loader/merge.ts
 var DANGEROUS_KEYS2 = new Set(["__proto__", "constructor", "prototype"]);
 function isUnsafeObjectKey2(key) {
@@ -87658,9 +87611,17 @@ function invalidValueDiagnostics(path, dropped) {
 function unrecognizedKeyIssues(issues) {
   return issues.flatMap((issue) => issue.code === "unrecognized_keys" ? [{ keys: issue.keys, path: issue.path.map((segment) => String(segment)) }] : []);
 }
-function isRecord13(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+var RETIRED_SECTION_DIGESTS = new Set([
+  "447f75a8ebdbdb79a57f0b8cebbfba183820cf54a8119ac01449b30499e5ef0e",
+  "4ea5ee68fea05586106890ded5733820bb77d919cda27bc4b8139b7cd33b8889"
+]);
+function isRetiredSection(key) {
+  return RETIRED_SECTION_DIGESTS.has(createHash3("sha256").update(key.toLowerCase()).digest("hex"));
+}
+var HARNESS_BLOCKS = new Set(["[opencode]", "[native]", "[senpi]", "[codex]"]);
 function sanitizeUnsafeKeys(value, path = []) {
   if (Array.isArray(value)) {
     const issues = [];
@@ -87671,7 +87632,7 @@ function sanitizeUnsafeKeys(value, path = []) {
     });
     return { issues, value: sanitized };
   }
-  if (!isRecord13(value))
+  if (!isRecord12(value))
     return { issues: [], value };
   const issues = [];
   if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
@@ -87679,6 +87640,9 @@ function sanitizeUnsafeKeys(value, path = []) {
   }
   const sanitized = {};
   for (const [key, entry] of Object.entries(value)) {
+    const isConfigContainer = path.length === 0 || path.length === 1 && HARNESS_BLOCKS.has(path[0] ?? "") || path.length === 2 && path[0] === "profiles" || path.length === 3 && path[0] === "profiles" && HARNESS_BLOCKS.has(path[2] ?? "");
+    if (isConfigContainer && isRetiredSection(key))
+      continue;
     if (isUnsafeObjectKey2(key)) {
       issues.push({ keys: [key], path });
       continue;
@@ -87697,13 +87661,13 @@ function containerAt(record, path) {
       if (!Number.isInteger(index) || index < 0 || index >= node.length)
         return null;
       node = node[index];
-    } else if (isRecord13(node) && Object.hasOwn(node, segment)) {
+    } else if (isRecord12(node) && Object.hasOwn(node, segment)) {
       node = node[segment];
     } else {
       return null;
     }
   }
-  return isRecord13(node) ? node : null;
+  return isRecord12(node) ? node : null;
 }
 function stripUnrecognizedKeys(record, issues) {
   const stripped = structuredClone(record);
@@ -89553,7 +89517,7 @@ init_src();
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "5.1.45",
+  version: "5.1.46",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -89799,18 +89763,18 @@ var package_default = {
     typescript: "^7.0.2"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "5.1.45",
-    "oh-my-opencode-darwin-x64": "5.1.45",
-    "oh-my-opencode-darwin-x64-baseline": "5.1.45",
-    "oh-my-opencode-linux-arm64": "5.1.45",
-    "oh-my-opencode-linux-arm64-musl": "5.1.45",
-    "oh-my-opencode-linux-x64": "5.1.45",
-    "oh-my-opencode-linux-x64-baseline": "5.1.45",
-    "oh-my-opencode-linux-x64-musl": "5.1.45",
-    "oh-my-opencode-linux-x64-musl-baseline": "5.1.45",
-    "oh-my-opencode-windows-arm64": "5.1.45",
-    "oh-my-opencode-windows-x64": "5.1.45",
-    "oh-my-opencode-windows-x64-baseline": "5.1.45"
+    "oh-my-opencode-darwin-arm64": "5.1.46",
+    "oh-my-opencode-darwin-x64": "5.1.46",
+    "oh-my-opencode-darwin-x64-baseline": "5.1.46",
+    "oh-my-opencode-linux-arm64": "5.1.46",
+    "oh-my-opencode-linux-arm64-musl": "5.1.46",
+    "oh-my-opencode-linux-x64": "5.1.46",
+    "oh-my-opencode-linux-x64-baseline": "5.1.46",
+    "oh-my-opencode-linux-x64-musl": "5.1.46",
+    "oh-my-opencode-linux-x64-musl-baseline": "5.1.46",
+    "oh-my-opencode-windows-arm64": "5.1.46",
+    "oh-my-opencode-windows-x64": "5.1.46",
+    "oh-my-opencode-windows-x64-baseline": "5.1.46"
   },
   overrides: {
     hono: "^4.13.8",
@@ -91113,8 +91077,8 @@ function findUnknownKeyPaths(schema, value) {
 }
 
 // packages/omo-opencode/src/config/schema/agent-names.ts
-import { z as z20 } from "zod";
-var BuiltinAgentNameSchema = z20.enum([
+import { z as z19 } from "zod";
+var BuiltinAgentNameSchema = z19.enum([
   "sisyphus",
   "hephaestus",
   "prometheus",
@@ -91127,7 +91091,7 @@ var BuiltinAgentNameSchema = z20.enum([
   "atlas",
   "sisyphus-junior"
 ]);
-var BuiltinSkillNameSchema = z20.enum([
+var BuiltinSkillNameSchema = z19.enum([
   "playwright",
   "dev-browser",
   "frontend",
@@ -91141,7 +91105,7 @@ var BuiltinSkillNameSchema = z20.enum([
   "visual-qa",
   "team-mode"
 ]);
-var OverridableAgentNameSchema = z20.enum([
+var OverridableAgentNameSchema = z19.enum([
   "build",
   "plan",
   "sisyphus",
@@ -91158,41 +91122,41 @@ var OverridableAgentNameSchema = z20.enum([
   "atlas"
 ]);
 // packages/omo-opencode/src/config/schema/agent-overrides.ts
-import { z as z23 } from "zod";
+import { z as z22 } from "zod";
 
 // packages/omo-opencode/src/config/schema/fallback-models.ts
-import { z as z21 } from "zod";
-var FallbackModelObjectSchema = z21.object({
-  model: z21.string(),
+import { z as z20 } from "zod";
+var FallbackModelObjectSchema = z20.object({
+  model: z20.string(),
   reasoning: OmoReasoningSchema.optional(),
-  variant: z21.string().optional(),
-  reasoningEffort: z21.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional(),
-  temperature: z21.number().min(0).max(2).optional(),
-  top_p: z21.number().min(0).max(1).optional(),
-  maxTokens: z21.number().optional(),
-  thinking: z21.object({
-    type: z21.enum(["enabled", "disabled"]),
-    budgetTokens: z21.number().optional()
+  variant: z20.string().optional(),
+  reasoningEffort: z20.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional(),
+  temperature: z20.number().min(0).max(2).optional(),
+  top_p: z20.number().min(0).max(1).optional(),
+  maxTokens: z20.number().optional(),
+  thinking: z20.object({
+    type: z20.enum(["enabled", "disabled"]),
+    budgetTokens: z20.number().optional()
   }).optional()
 });
-var FallbackModelStringArraySchema = z21.array(z21.string());
-var FallbackModelObjectArraySchema = z21.array(FallbackModelObjectSchema);
-var FallbackModelMixedArraySchema = z21.array(z21.union([z21.string(), FallbackModelObjectSchema]));
-var FallbackModelsSchema = z21.union([
-  z21.string(),
+var FallbackModelStringArraySchema = z20.array(z20.string());
+var FallbackModelObjectArraySchema = z20.array(FallbackModelObjectSchema);
+var FallbackModelMixedArraySchema = z20.array(z20.union([z20.string(), FallbackModelObjectSchema]));
+var FallbackModelsSchema = z20.union([
+  z20.string(),
   FallbackModelStringArraySchema,
   FallbackModelObjectArraySchema,
   FallbackModelMixedArraySchema
 ]);
 
 // packages/omo-opencode/src/config/schema/internal/permission.ts
-import { z as z22 } from "zod";
-var PermissionValueSchema2 = z22.enum(["ask", "allow", "deny"]);
-var BashPermissionSchema2 = z22.union([
+import { z as z21 } from "zod";
+var PermissionValueSchema2 = z21.enum(["ask", "allow", "deny"]);
+var BashPermissionSchema2 = z21.union([
   PermissionValueSchema2,
-  z22.record(z22.string(), PermissionValueSchema2)
+  z21.record(z21.string(), PermissionValueSchema2)
 ]);
-var AgentPermissionSchema = z22.object({
+var AgentPermissionSchema = z21.object({
   edit: PermissionValueSchema2.optional(),
   bash: BashPermissionSchema2.optional(),
   webfetch: PermissionValueSchema2.optional(),
@@ -91202,50 +91166,50 @@ var AgentPermissionSchema = z22.object({
 }).catchall(PermissionValueSchema2.optional());
 
 // packages/omo-opencode/src/config/schema/agent-overrides.ts
-var AgentOverrideConfigSchema = z23.object({
-  model: z23.string().optional(),
-  models: z23.array(z23.union([z23.string(), FallbackModelObjectSchema])).optional(),
+var AgentOverrideConfigSchema = z22.object({
+  model: z22.string().optional(),
+  models: z22.array(z22.union([z22.string(), FallbackModelObjectSchema])).optional(),
   fallback_models: FallbackModelsSchema.optional(),
   reasoning: OmoReasoningSchema.optional(),
-  variant: z23.string().optional(),
-  category: z23.string().optional(),
-  skills: z23.array(z23.string()).optional(),
-  temperature: z23.number().min(0).max(2).optional(),
-  top_p: z23.number().min(0).max(1).optional(),
-  prompt: z23.string().optional(),
-  prompt_append: z23.string().optional(),
-  tools: z23.record(z23.string(), z23.boolean()).optional(),
-  disable: z23.boolean().optional(),
-  description: z23.string().optional(),
-  mode: z23.enum(["subagent", "primary", "all"]).optional(),
-  color: z23.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
-  displayName: z23.string().optional(),
+  variant: z22.string().optional(),
+  category: z22.string().optional(),
+  skills: z22.array(z22.string()).optional(),
+  temperature: z22.number().min(0).max(2).optional(),
+  top_p: z22.number().min(0).max(1).optional(),
+  prompt: z22.string().optional(),
+  prompt_append: z22.string().optional(),
+  tools: z22.record(z22.string(), z22.boolean()).optional(),
+  disable: z22.boolean().optional(),
+  description: z22.string().optional(),
+  mode: z22.enum(["subagent", "primary", "all"]).optional(),
+  color: z22.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
+  displayName: z22.string().optional(),
   permission: AgentPermissionSchema.optional(),
-  maxTokens: z23.number().optional(),
-  thinking: z23.object({
-    type: z23.enum(["enabled", "disabled"]),
-    budgetTokens: z23.number().optional()
+  maxTokens: z22.number().optional(),
+  thinking: z22.object({
+    type: z22.enum(["enabled", "disabled"]),
+    budgetTokens: z22.number().optional()
   }).optional(),
-  reasoningEffort: z23.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional(),
-  textVerbosity: z23.enum(["low", "medium", "high"]).optional(),
-  providerOptions: z23.record(z23.string(), z23.unknown()).optional(),
-  ultrawork: z23.object({
-    model: z23.string().optional(),
+  reasoningEffort: z22.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional(),
+  textVerbosity: z22.enum(["low", "medium", "high"]).optional(),
+  providerOptions: z22.record(z22.string(), z22.unknown()).optional(),
+  ultrawork: z22.object({
+    model: z22.string().optional(),
     reasoning: OmoReasoningSchema.optional(),
-    variant: z23.string().optional()
+    variant: z22.string().optional()
   }).optional(),
-  compaction: z23.object({
-    model: z23.string().optional(),
+  compaction: z22.object({
+    model: z22.string().optional(),
     reasoning: OmoReasoningSchema.optional(),
-    variant: z23.string().optional()
+    variant: z22.string().optional()
   }).optional()
 });
-var AgentOverridesSchema = z23.object({
+var AgentOverridesSchema = z22.object({
   build: AgentOverrideConfigSchema.optional(),
   plan: AgentOverrideConfigSchema.optional(),
   sisyphus: AgentOverrideConfigSchema.optional(),
   hephaestus: AgentOverrideConfigSchema.extend({
-    allow_non_gpt_model: z23.boolean().optional()
+    allow_non_gpt_model: z22.boolean().optional()
   }).optional(),
   "sisyphus-junior": AgentOverrideConfigSchema.optional(),
   "OpenCode-Builder": AgentOverrideConfigSchema.optional(),
@@ -91259,73 +91223,73 @@ var AgentOverridesSchema = z23.object({
   atlas: AgentOverrideConfigSchema.optional()
 }).catchall(AgentOverrideConfigSchema.optional());
 // packages/omo-opencode/src/config/schema/babysitting.ts
-import { z as z24 } from "zod";
-var BabysittingConfigSchema = z24.object({
-  timeout_ms: z24.number().default(120000)
+import { z as z23 } from "zod";
+var BabysittingConfigSchema = z23.object({
+  timeout_ms: z23.number().default(120000)
 });
 // packages/omo-opencode/src/config/schema/background-task.ts
-import { z as z25 } from "zod";
-var CircuitBreakerConfigSchema = z25.object({
-  enabled: z25.boolean().optional(),
-  maxToolCalls: z25.number().int().min(10).optional(),
-  consecutiveThreshold: z25.number().int().min(5).optional()
+import { z as z24 } from "zod";
+var CircuitBreakerConfigSchema = z24.object({
+  enabled: z24.boolean().optional(),
+  maxToolCalls: z24.number().int().min(10).optional(),
+  consecutiveThreshold: z24.number().int().min(5).optional()
 });
-var BackgroundTaskConfigSchema = z25.object({
-  defaultConcurrency: z25.number().min(0).optional(),
-  providerConcurrency: z25.record(z25.string(), z25.number().min(0)).optional(),
-  modelConcurrency: z25.record(z25.string(), z25.number().min(0)).optional(),
-  maxDepth: z25.number().int().min(1).optional(),
-  maxLiveDescendantsPerRoot: z25.number().int().min(0).optional(),
-  staleTimeoutMs: z25.number().min(60000).optional(),
-  messageStalenessTimeoutMs: z25.number().min(60000).optional(),
-  taskTtlMs: z25.number().min(300000).optional(),
-  sessionGoneTimeoutMs: z25.number().min(1e4).optional(),
-  taskCleanupDelayMs: z25.number().min(60000).optional(),
-  syncPollTimeoutMs: z25.number().min(60000).optional(),
-  maxToolCalls: z25.number().int().min(10).optional(),
+var BackgroundTaskConfigSchema = z24.object({
+  defaultConcurrency: z24.number().min(0).optional(),
+  providerConcurrency: z24.record(z24.string(), z24.number().min(0)).optional(),
+  modelConcurrency: z24.record(z24.string(), z24.number().min(0)).optional(),
+  maxDepth: z24.number().int().min(1).optional(),
+  maxLiveDescendantsPerRoot: z24.number().int().min(0).optional(),
+  staleTimeoutMs: z24.number().min(60000).optional(),
+  messageStalenessTimeoutMs: z24.number().min(60000).optional(),
+  taskTtlMs: z24.number().min(300000).optional(),
+  sessionGoneTimeoutMs: z24.number().min(1e4).optional(),
+  taskCleanupDelayMs: z24.number().min(60000).optional(),
+  syncPollTimeoutMs: z24.number().min(60000).optional(),
+  maxToolCalls: z24.number().int().min(10).optional(),
   circuitBreaker: CircuitBreakerConfigSchema.optional()
 });
 // packages/omo-opencode/src/config/schema/browser-automation.ts
-import { z as z26 } from "zod";
-var BrowserAutomationProviderSchema = z26.enum([
+import { z as z25 } from "zod";
+var BrowserAutomationProviderSchema = z25.enum([
   "playwright",
   "dev-browser",
   "playwright-cli"
 ], {
   error: (issue) => `Browser provider ${JSON.stringify(issue.input)} is no longer supported; use the built-in browser path: Bun.WebView / playwright-core scripts`
 });
-var BrowserAutomationConfigSchema = z26.object({
+var BrowserAutomationConfigSchema = z25.object({
   provider: BrowserAutomationProviderSchema.default("playwright"),
-  playwright_mcp_args: z26.array(z26.string()).optional()
+  playwright_mcp_args: z25.array(z25.string()).optional()
 });
 // packages/omo-opencode/src/config/schema/categories.ts
-import { z as z27 } from "zod";
-var CategoryConfigSchema = z27.object({
-  description: z27.string().optional(),
-  model: z27.string().optional(),
-  models: z27.array(z27.union([z27.string(), FallbackModelObjectSchema])).optional(),
+import { z as z26 } from "zod";
+var CategoryConfigSchema = z26.object({
+  description: z26.string().optional(),
+  model: z26.string().optional(),
+  models: z26.array(z26.union([z26.string(), FallbackModelObjectSchema])).optional(),
   fallback_models: FallbackModelsSchema.optional(),
   reasoning: OmoReasoningSchema.optional(),
-  variant: z27.string().optional(),
-  temperature: z27.number().min(0).max(2).optional(),
-  top_p: z27.number().min(0).max(1).optional(),
-  max_tokens: z27.number().int().positive().optional(),
-  provider_options: z27.record(z27.string(), z27.unknown()).optional(),
-  maxTokens: z27.number().optional(),
-  thinking: z27.object({
-    type: z27.enum(["enabled", "disabled"]),
-    budgetTokens: z27.number().optional()
+  variant: z26.string().optional(),
+  temperature: z26.number().min(0).max(2).optional(),
+  top_p: z26.number().min(0).max(1).optional(),
+  max_tokens: z26.number().int().positive().optional(),
+  provider_options: z26.record(z26.string(), z26.unknown()).optional(),
+  maxTokens: z26.number().optional(),
+  thinking: z26.object({
+    type: z26.enum(["enabled", "disabled"]),
+    budgetTokens: z26.number().optional()
   }).optional(),
-  reasoningEffort: z27.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional(),
-  textVerbosity: z27.enum(["low", "medium", "high"]).optional(),
-  tools: z27.record(z27.string(), z27.boolean()).optional(),
-  prompt_append: z27.string().optional(),
-  max_prompt_tokens: z27.number().int().positive().optional(),
-  is_unstable_agent: z27.boolean().optional(),
-  disable: z27.boolean().optional(),
-  warn_unavailable: z27.boolean().optional()
+  reasoningEffort: z26.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional(),
+  textVerbosity: z26.enum(["low", "medium", "high"]).optional(),
+  tools: z26.record(z26.string(), z26.boolean()).optional(),
+  prompt_append: z26.string().optional(),
+  max_prompt_tokens: z26.number().int().positive().optional(),
+  is_unstable_agent: z26.boolean().optional(),
+  disable: z26.boolean().optional(),
+  warn_unavailable: z26.boolean().optional()
 });
-var BuiltinCategoryNameSchema = z27.enum([
+var BuiltinCategoryNameSchema = z26.enum([
   "visual-engineering",
   "ultrabrain",
   "deep",
@@ -91335,29 +91299,29 @@ var BuiltinCategoryNameSchema = z27.enum([
   "unspecified-high",
   "writing"
 ]);
-var CategoriesConfigSchema = z27.record(z27.string(), CategoryConfigSchema);
+var CategoriesConfigSchema = z26.record(z26.string(), CategoryConfigSchema);
 // packages/omo-opencode/src/config/schema/claude-code.ts
-import { z as z28 } from "zod";
-var ClaudeCodeConfigSchema = z28.object({
-  mcp: z28.boolean().optional(),
-  commands: z28.boolean().optional(),
-  skills: z28.boolean().optional(),
-  agents: z28.boolean().optional(),
-  hooks: z28.boolean().optional(),
-  plugins: z28.boolean().optional(),
-  plugins_override: z28.record(z28.string(), z28.boolean()).optional(),
-  anthropic_provider: z28.string().trim().min(1).refine((v) => !v.includes("/"), {
+import { z as z27 } from "zod";
+var ClaudeCodeConfigSchema = z27.object({
+  mcp: z27.boolean().optional(),
+  commands: z27.boolean().optional(),
+  skills: z27.boolean().optional(),
+  agents: z27.boolean().optional(),
+  hooks: z27.boolean().optional(),
+  plugins: z27.boolean().optional(),
+  plugins_override: z27.record(z27.string(), z27.boolean()).optional(),
+  anthropic_provider: z27.string().trim().min(1).refine((v) => !v.includes("/"), {
     message: "anthropic_provider must be a provider name without '/'"
   }).optional()
 });
 // packages/omo-opencode/src/config/schema/comment-checker.ts
-import { z as z29 } from "zod";
-var CommentCheckerConfigSchema = z29.object({
-  custom_prompt: z29.string().optional()
+import { z as z28 } from "zod";
+var CommentCheckerConfigSchema = z28.object({
+  custom_prompt: z28.string().optional()
 });
 // packages/omo-opencode/src/config/schema/commands.ts
-import { z as z30 } from "zod";
-var BuiltinCommandNameSchema = z30.enum([
+import { z as z29 } from "zod";
+var BuiltinCommandNameSchema = z29.enum([
   "goal",
   "refactor",
   "ulw-execute",
@@ -91366,21 +91330,21 @@ var BuiltinCommandNameSchema = z30.enum([
   "hyperplan"
 ]);
 // packages/omo-opencode/src/config/schema/default-mode.ts
-import { z as z31 } from "zod";
-var DefaultModeConfigSchema = z31.object({
-  ultrawork: z31.boolean().default(false),
-  goal: z31.boolean().default(false)
+import { z as z30 } from "zod";
+var DefaultModeConfigSchema = z30.object({
+  ultrawork: z30.boolean().default(false),
+  goal: z30.boolean().default(false)
 });
 // packages/omo-opencode/src/config/schema/dynamic-context-pruning.ts
-import { z as z32 } from "zod";
-var DynamicContextPruningConfigSchema = z32.object({
-  enabled: z32.boolean().default(false),
-  notification: z32.enum(["off", "minimal", "detailed"]).default("detailed"),
-  turn_protection: z32.object({
-    enabled: z32.boolean().default(true),
-    turns: z32.number().min(1).max(10).default(3)
+import { z as z31 } from "zod";
+var DynamicContextPruningConfigSchema = z31.object({
+  enabled: z31.boolean().default(false),
+  notification: z31.enum(["off", "minimal", "detailed"]).default("detailed"),
+  turn_protection: z31.object({
+    enabled: z31.boolean().default(true),
+    turns: z31.number().min(1).max(10).default(3)
   }).optional(),
-  protected_tools: z32.array(z32.string()).default([
+  protected_tools: z31.array(z31.string()).default([
     "task",
     "todowrite",
     "todoread",
@@ -91389,45 +91353,45 @@ var DynamicContextPruningConfigSchema = z32.object({
     "session_write",
     "session_search"
   ]),
-  strategies: z32.object({
-    deduplication: z32.object({
-      enabled: z32.boolean().default(true)
+  strategies: z31.object({
+    deduplication: z31.object({
+      enabled: z31.boolean().default(true)
     }).optional(),
-    supersede_writes: z32.object({
-      enabled: z32.boolean().default(true),
-      aggressive: z32.boolean().default(false)
+    supersede_writes: z31.object({
+      enabled: z31.boolean().default(true),
+      aggressive: z31.boolean().default(false)
     }).optional(),
-    purge_errors: z32.object({
-      enabled: z32.boolean().default(true),
-      turns: z32.number().min(1).max(20).default(5)
+    purge_errors: z31.object({
+      enabled: z31.boolean().default(true),
+      turns: z31.number().min(1).max(20).default(5)
     }).optional()
   }).optional()
 });
 // packages/omo-opencode/src/config/schema/experimental.ts
-import { z as z33 } from "zod";
-var ExperimentalConfigSchema = z33.object({
-  aggressive_truncation: z33.boolean().optional(),
-  preemptive_compaction: z33.boolean().optional(),
-  truncate_all_tool_outputs: z33.boolean().optional(),
+import { z as z32 } from "zod";
+var ExperimentalConfigSchema = z32.object({
+  aggressive_truncation: z32.boolean().optional(),
+  preemptive_compaction: z32.boolean().optional(),
+  truncate_all_tool_outputs: z32.boolean().optional(),
   dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
-  task_system: z33.boolean().optional(),
-  plugin_load_timeout_ms: z33.number().min(1000).optional(),
-  safe_hook_creation: z33.boolean().optional(),
-  disable_omo_env: z33.boolean().optional(),
-  hashline_edit: z33.boolean().optional(),
-  model_fallback_title: z33.boolean().optional(),
-  max_tools: z33.number().int().min(1).optional(),
-  disable_live_parent_wake_routing: z33.boolean().optional()
+  task_system: z32.boolean().optional(),
+  plugin_load_timeout_ms: z32.number().min(1000).optional(),
+  safe_hook_creation: z32.boolean().optional(),
+  disable_omo_env: z32.boolean().optional(),
+  hashline_edit: z32.boolean().optional(),
+  model_fallback_title: z32.boolean().optional(),
+  max_tools: z32.number().int().min(1).optional(),
+  disable_live_parent_wake_routing: z32.boolean().optional()
 });
 // packages/omo-opencode/src/config/schema/goal.ts
-import { z as z34 } from "zod";
-var GoalConfigSchema = z34.object({
-  enabled: z34.boolean().default(false),
-  auto_start: z34.boolean().default(false),
-  default_max_iterations: z34.number().min(1).max(1000).default(100)
+import { z as z33 } from "zod";
+var GoalConfigSchema = z33.object({
+  enabled: z33.boolean().default(false),
+  auto_start: z33.boolean().default(false),
+  default_max_iterations: z33.number().min(1).max(1000).default(100)
 });
 // packages/skills-loader-core/src/config/git-env-prefix.ts
-import { z as z35 } from "zod";
+import { z as z34 } from "zod";
 var GIT_ENV_ASSIGNMENT_PATTERN2 = /^(?:[A-Za-z_][A-Za-z0-9_]*=[A-Za-z0-9_-]*)(?: [A-Za-z_][A-Za-z0-9_]*=[A-Za-z0-9_-]*)*$/;
 var GIT_ENV_PREFIX_VALIDATION_MESSAGE = 'git_env_prefix must be empty or use shell-safe env assignments like "GIT_MASTER=1"';
 function isValidGitEnvPrefix(value) {
@@ -91442,17 +91406,17 @@ function assertValidGitEnvPrefix(value) {
   }
   return value;
 }
-var GitEnvPrefixSchema2 = z35.string().refine(isValidGitEnvPrefix, { message: GIT_ENV_PREFIX_VALIDATION_MESSAGE }).default("GIT_MASTER=1");
+var GitEnvPrefixSchema2 = z34.string().refine(isValidGitEnvPrefix, { message: GIT_ENV_PREFIX_VALIDATION_MESSAGE }).default("GIT_MASTER=1");
 // packages/omo-opencode/src/config/schema/git-master.ts
-import { z as z36 } from "zod";
-var GitMasterConfigSchema = z36.object({
-  commit_footer: z36.union([z36.boolean(), z36.string()]).default(false),
-  include_co_authored_by: z36.boolean().default(true),
+import { z as z35 } from "zod";
+var GitMasterConfigSchema = z35.object({
+  commit_footer: z35.union([z35.boolean(), z35.string()]).default(false),
+  include_co_authored_by: z35.boolean().default(true),
   git_env_prefix: GitEnvPrefixSchema2
 });
 // packages/omo-opencode/src/config/schema/hooks.ts
-import { z as z37 } from "zod";
-var HookNameSchema = z37.enum([
+import { z as z36 } from "zod";
+var HookNameSchema = z36.enum([
   "todo-continuation-enforcer",
   "session-notification",
   "comment-checker",
@@ -91511,240 +91475,240 @@ var HookNameSchema = z37.enum([
   "native-edition-nudge"
 ]);
 // packages/omo-opencode/src/config/schema/i18n.ts
-import { z as z38 } from "zod";
-var I18nConfigSchema = z38.object({
-  locale: z38.string().optional()
+import { z as z37 } from "zod";
+var I18nConfigSchema = z37.object({
+  locale: z37.string().optional()
 });
 // packages/omo-opencode/src/config/schema/keyword-detector.ts
-import { z as z39 } from "zod";
-var KeywordTypeSchema = z39.enum(["ultrawork", "team", "hyperplan", "hyperplan-ultrawork"]);
-var KeywordDetectorConfigSchema = z39.object({
-  enabled_expansions: z39.array(KeywordTypeSchema).optional(),
-  disabled_keywords: z39.array(KeywordTypeSchema).optional()
+import { z as z38 } from "zod";
+var KeywordTypeSchema = z38.enum(["ultrawork", "team", "hyperplan", "hyperplan-ultrawork"]);
+var KeywordDetectorConfigSchema = z38.object({
+  enabled_expansions: z38.array(KeywordTypeSchema).optional(),
+  disabled_keywords: z38.array(KeywordTypeSchema).optional()
 });
 // packages/omo-opencode/src/config/schema/model-capabilities.ts
-import { z as z40 } from "zod";
-var ModelCapabilitiesConfigSchema = z40.object({
-  enabled: z40.boolean().optional(),
-  auto_refresh_on_start: z40.boolean().optional(),
-  refresh_timeout_ms: z40.number().int().positive().optional(),
-  source_url: z40.string().url().optional()
+import { z as z39 } from "zod";
+var ModelCapabilitiesConfigSchema = z39.object({
+  enabled: z39.boolean().optional(),
+  auto_refresh_on_start: z39.boolean().optional(),
+  refresh_timeout_ms: z39.number().int().positive().optional(),
+  source_url: z39.string().url().optional()
 });
 // packages/omo-opencode/src/config/schema/notification.ts
-import { z as z41 } from "zod";
-var NotificationConfigSchema = z41.object({
-  force_enable: z41.boolean().optional()
+import { z as z40 } from "zod";
+var NotificationConfigSchema = z40.object({
+  force_enable: z40.boolean().optional()
 });
 // packages/omo-opencode/src/config/schema/oh-my-opencode-config.ts
-import { z as z55 } from "zod";
+import { z as z54 } from "zod";
 
 // packages/omo-opencode/src/mcp/types.ts
-import { z as z42 } from "zod";
-var McpNameSchema = z42.enum(["websearch", "context7", "grep_app", "lsp"]);
-var AnyMcpNameSchema = z42.string().min(1);
+import { z as z41 } from "zod";
+var McpNameSchema = z41.enum(["websearch", "context7", "grep_app", "lsp"]);
+var AnyMcpNameSchema = z41.string().min(1);
 
 // packages/omo-opencode/src/config/schema/agent-definitions.ts
-import { z as z43 } from "zod";
-var AgentDefinitionPathSchema = z43.string().min(1);
-var AgentDefinitionsConfigSchema = z43.array(AgentDefinitionPathSchema).optional();
+import { z as z42 } from "zod";
+var AgentDefinitionPathSchema = z42.string().min(1);
+var AgentDefinitionsConfigSchema = z42.array(AgentDefinitionPathSchema).optional();
 
 // packages/omo-opencode/src/config/schema/openclaw.ts
-import { z as z44 } from "zod";
-var OpenClawGatewaySchema = z44.object({
-  type: z44.enum(["http", "command"]).default("http"),
-  url: z44.string().optional(),
-  method: z44.string().default("POST"),
-  headers: z44.record(z44.string(), z44.string()).optional(),
-  command: z44.string().optional(),
-  timeout: z44.number().optional()
+import { z as z43 } from "zod";
+var OpenClawGatewaySchema = z43.object({
+  type: z43.enum(["http", "command"]).default("http"),
+  url: z43.string().optional(),
+  method: z43.string().default("POST"),
+  headers: z43.record(z43.string(), z43.string()).optional(),
+  command: z43.string().optional(),
+  timeout: z43.number().optional()
 });
-var OpenClawHookSchema = z44.object({
-  enabled: z44.boolean().default(true),
-  gateway: z44.string(),
-  instruction: z44.string()
+var OpenClawHookSchema = z43.object({
+  enabled: z43.boolean().default(true),
+  gateway: z43.string(),
+  instruction: z43.string()
 });
-var OpenClawReplyListenerConfigSchema = z44.object({
-  discordBotToken: z44.string().optional(),
-  discordChannelId: z44.string().optional(),
-  discordMention: z44.string().optional(),
-  authorizedDiscordUserIds: z44.array(z44.string()).default([]),
-  telegramBotToken: z44.string().optional(),
-  telegramChatId: z44.string().optional(),
-  pollIntervalMs: z44.number().default(3000),
-  rateLimitPerMinute: z44.number().default(10),
-  maxMessageLength: z44.number().default(500),
-  includePrefix: z44.boolean().default(true)
+var OpenClawReplyListenerConfigSchema = z43.object({
+  discordBotToken: z43.string().optional(),
+  discordChannelId: z43.string().optional(),
+  discordMention: z43.string().optional(),
+  authorizedDiscordUserIds: z43.array(z43.string()).default([]),
+  telegramBotToken: z43.string().optional(),
+  telegramChatId: z43.string().optional(),
+  pollIntervalMs: z43.number().default(3000),
+  rateLimitPerMinute: z43.number().default(10),
+  maxMessageLength: z43.number().default(500),
+  includePrefix: z43.boolean().default(true)
 });
-var OpenClawConfigSchema = z44.object({
-  enabled: z44.boolean().default(false),
-  gateways: z44.record(z44.string(), OpenClawGatewaySchema).default({}),
-  hooks: z44.record(z44.string(), OpenClawHookSchema).default({}),
+var OpenClawConfigSchema = z43.object({
+  enabled: z43.boolean().default(false),
+  gateways: z43.record(z43.string(), OpenClawGatewaySchema).default({}),
+  hooks: z43.record(z43.string(), OpenClawHookSchema).default({}),
   replyListener: OpenClawReplyListenerConfigSchema.optional()
 });
 
 // packages/omo-opencode/src/config/schema/monitor.ts
-import { z as z45 } from "zod";
-var MonitorConfigSchema = z45.object({
-  enabled: z45.boolean().default(false),
-  live_mode_enabled: z45.boolean().default(false),
-  allowed_commands: z45.array(z45.string()).optional(),
-  max_monitors_per_session: z45.number().int().min(1).max(16).default(3),
-  max_runtime_ms: z45.number().int().min(1000).default(1800000),
-  batch_max_lines: z45.number().int().min(1).default(50),
-  batch_max_bytes: z45.number().int().min(1024).default(16384),
-  flush_interval_ms: z45.number().int().min(250).default(1000),
-  ring_max_lines: z45.number().int().min(1).default(1000),
-  line_max_bytes: z45.number().int().min(256).default(8192),
-  pattern_max_length: z45.number().int().min(1).default(512)
+import { z as z44 } from "zod";
+var MonitorConfigSchema = z44.object({
+  enabled: z44.boolean().default(false),
+  live_mode_enabled: z44.boolean().default(false),
+  allowed_commands: z44.array(z44.string()).optional(),
+  max_monitors_per_session: z44.number().int().min(1).max(16).default(3),
+  max_runtime_ms: z44.number().int().min(1000).default(1800000),
+  batch_max_lines: z44.number().int().min(1).default(50),
+  batch_max_bytes: z44.number().int().min(1024).default(16384),
+  flush_interval_ms: z44.number().int().min(250).default(1000),
+  ring_max_lines: z44.number().int().min(1).default(1000),
+  line_max_bytes: z44.number().int().min(256).default(8192),
+  pattern_max_length: z44.number().int().min(1).default(512)
 });
 
 // packages/omo-opencode/src/config/schema/runtime-fallback.ts
-import { z as z46 } from "zod";
-var RuntimeFallbackConfigSchema = z46.object({
-  enabled: z46.boolean().optional(),
-  retry_on_errors: z46.array(z46.number()).optional(),
-  max_fallback_attempts: z46.number().min(1).max(20).optional(),
-  cooldown_seconds: z46.number().min(0).optional(),
-  timeout_seconds: z46.number().min(0).optional(),
-  notify_on_fallback: z46.boolean().optional(),
-  restore_primary_after_cooldown: z46.boolean().optional()
+import { z as z45 } from "zod";
+var RuntimeFallbackConfigSchema = z45.object({
+  enabled: z45.boolean().optional(),
+  retry_on_errors: z45.array(z45.number()).optional(),
+  max_fallback_attempts: z45.number().min(1).max(20).optional(),
+  cooldown_seconds: z45.number().min(0).optional(),
+  timeout_seconds: z45.number().min(0).optional(),
+  notify_on_fallback: z45.boolean().optional(),
+  restore_primary_after_cooldown: z45.boolean().optional()
 });
 
 // packages/team-core/src/config.ts
-import * as z47 from "zod";
-var TeamModeConfigSchema = z47.object({
-  enabled: z47.boolean().default(false),
-  tmux_visualization: z47.boolean().default(false),
-  max_parallel_members: z47.number().int().min(1).max(8).default(4),
-  max_members: z47.number().int().min(1).max(8).default(8),
-  max_messages_per_run: z47.number().int().min(1).default(1e4),
-  max_wall_clock_minutes: z47.number().int().min(1).default(120),
-  max_member_turns: z47.number().int().min(1).default(500),
-  base_dir: z47.string().optional(),
-  message_payload_max_bytes: z47.number().int().min(1024).default(32768),
-  recipient_unread_max_bytes: z47.number().int().min(1024).default(262144),
-  mailbox_poll_interval_ms: z47.number().int().min(500).default(3000)
+import * as z46 from "zod";
+var TeamModeConfigSchema = z46.object({
+  enabled: z46.boolean().default(false),
+  tmux_visualization: z46.boolean().default(false),
+  max_parallel_members: z46.number().int().min(1).max(8).default(4),
+  max_members: z46.number().int().min(1).max(8).default(8),
+  max_messages_per_run: z46.number().int().min(1).default(1e4),
+  max_wall_clock_minutes: z46.number().int().min(1).default(120),
+  max_member_turns: z46.number().int().min(1).default(500),
+  base_dir: z46.string().optional(),
+  message_payload_max_bytes: z46.number().int().min(1024).default(32768),
+  recipient_unread_max_bytes: z46.number().int().min(1024).default(262144),
+  mailbox_poll_interval_ms: z46.number().int().min(500).default(3000)
 });
 // packages/omo-opencode/src/config/schema/skills.ts
-import { z as z48 } from "zod";
-var SkillSourceSchema = z48.union([
-  z48.string(),
-  z48.object({
-    path: z48.string(),
-    recursive: z48.boolean().optional(),
-    glob: z48.string().optional()
+import { z as z47 } from "zod";
+var SkillSourceSchema = z47.union([
+  z47.string(),
+  z47.object({
+    path: z47.string(),
+    recursive: z47.boolean().optional(),
+    glob: z47.string().optional()
   })
 ]);
-var SkillDefinitionSchema = z48.object({
-  description: z48.string().optional(),
-  template: z48.string().optional(),
-  from: z48.string().optional(),
-  model: z48.string().optional(),
-  agent: z48.string().optional(),
-  subtask: z48.boolean().optional(),
-  "argument-hint": z48.string().optional(),
-  license: z48.string().optional(),
-  compatibility: z48.string().optional(),
-  metadata: z48.record(z48.string(), z48.unknown()).optional(),
-  "allowed-tools": z48.array(z48.string()).optional(),
-  disable: z48.boolean().optional()
+var SkillDefinitionSchema = z47.object({
+  description: z47.string().optional(),
+  template: z47.string().optional(),
+  from: z47.string().optional(),
+  model: z47.string().optional(),
+  agent: z47.string().optional(),
+  subtask: z47.boolean().optional(),
+  "argument-hint": z47.string().optional(),
+  license: z47.string().optional(),
+  compatibility: z47.string().optional(),
+  metadata: z47.record(z47.string(), z47.unknown()).optional(),
+  "allowed-tools": z47.array(z47.string()).optional(),
+  disable: z47.boolean().optional()
 });
-var SkillEntrySchema = z48.union([z48.boolean(), SkillDefinitionSchema]);
-var SkillsConfigSchema = z48.union([
-  z48.array(z48.string()),
-  z48.object({
-    sources: z48.array(SkillSourceSchema).optional(),
-    enable: z48.array(z48.string()).optional(),
-    disable: z48.array(z48.string()).optional()
+var SkillEntrySchema = z47.union([z47.boolean(), SkillDefinitionSchema]);
+var SkillsConfigSchema = z47.union([
+  z47.array(z47.string()),
+  z47.object({
+    sources: z47.array(SkillSourceSchema).optional(),
+    enable: z47.array(z47.string()).optional(),
+    disable: z47.array(z47.string()).optional()
   }).catchall(SkillEntrySchema)
 ]);
 
 // packages/omo-opencode/src/config/schema/sisyphus.ts
-import { z as z49 } from "zod";
-var SisyphusTasksConfigSchema = z49.object({
-  storage_path: z49.string().optional(),
-  task_list_id: z49.string().optional(),
-  claude_code_compat: z49.boolean().default(false)
+import { z as z48 } from "zod";
+var SisyphusTasksConfigSchema = z48.object({
+  storage_path: z48.string().optional(),
+  task_list_id: z48.string().optional(),
+  claude_code_compat: z48.boolean().default(false)
 });
-var SisyphusConfigSchema = z49.object({
+var SisyphusConfigSchema = z48.object({
   tasks: SisyphusTasksConfigSchema.optional()
 });
 
 // packages/omo-opencode/src/config/schema/sisyphus-agent.ts
-import { z as z50 } from "zod";
-var SisyphusAgentConfigSchema = z50.object({
-  disabled: z50.boolean().optional(),
-  default_builder_enabled: z50.boolean().optional(),
-  planner_enabled: z50.boolean().optional(),
-  replace_plan: z50.boolean().optional(),
-  tdd: z50.boolean().default(true).optional()
+import { z as z49 } from "zod";
+var SisyphusAgentConfigSchema = z49.object({
+  disabled: z49.boolean().optional(),
+  default_builder_enabled: z49.boolean().optional(),
+  planner_enabled: z49.boolean().optional(),
+  replace_plan: z49.boolean().optional(),
+  tdd: z49.boolean().default(true).optional()
 });
 
 // packages/omo-opencode/src/config/schema/tmux.ts
 init_src2();
-import { z as z51 } from "zod";
-var TmuxLayoutSchema = z51.enum(TMUX_LAYOUT_VALUES);
-var TmuxIsolationSchema = z51.enum(TMUX_ISOLATION_VALUES);
-var TmuxConfigSchema = z51.object({
-  enabled: z51.boolean().default(false),
+import { z as z50 } from "zod";
+var TmuxLayoutSchema = z50.enum(TMUX_LAYOUT_VALUES);
+var TmuxIsolationSchema = z50.enum(TMUX_ISOLATION_VALUES);
+var TmuxConfigSchema = z50.object({
+  enabled: z50.boolean().default(false),
   layout: TmuxLayoutSchema.default("main-vertical"),
-  main_pane_size: z51.number().min(20).max(80).default(60),
-  main_pane_min_width: z51.number().min(40).default(120),
-  agent_pane_min_width: z51.number().min(20).default(40),
+  main_pane_size: z50.number().min(20).max(80).default(60),
+  main_pane_min_width: z50.number().min(40).default(120),
+  agent_pane_min_width: z50.number().min(20).default(40),
   isolation: TmuxIsolationSchema.default("inline")
 });
 
 // packages/omo-opencode/src/config/schema/tui.ts
-import { z as z52 } from "zod";
-var TuiSidebarConfigSchema = z52.object({
-  enabled: z52.boolean().default(true)
+import { z as z51 } from "zod";
+var TuiSidebarConfigSchema = z51.object({
+  enabled: z51.boolean().default(true)
 });
-var TuiConfigSchema = z52.object({
+var TuiConfigSchema = z51.object({
   sidebar: TuiSidebarConfigSchema.default({ enabled: true })
 });
 
 // packages/omo-opencode/src/config/schema/ulw-execute.ts
-import { z as z53 } from "zod";
-var UlwExecuteConfigSchema = z53.object({
-  auto_commit: z53.boolean().default(true)
+import { z as z52 } from "zod";
+var UlwExecuteConfigSchema = z52.object({
+  auto_commit: z52.boolean().default(true)
 });
 
 // packages/omo-opencode/src/config/schema/websearch.ts
-import { z as z54 } from "zod";
-var WebsearchProviderSchema = z54.enum(["exa", "tavily"]);
-var WebsearchConfigSchema = z54.object({
+import { z as z53 } from "zod";
+var WebsearchProviderSchema = z53.enum(["exa", "tavily"]);
+var WebsearchConfigSchema = z53.object({
   provider: WebsearchProviderSchema.optional()
 });
 
 // packages/omo-opencode/src/config/schema/oh-my-opencode-config.ts
-var OhMyOpenCodeConfigSchema = z55.object({
-  $schema: z55.string().optional(),
-  new_task_system_enabled: z55.boolean().optional(),
-  default_run_agent: z55.string().optional(),
-  agent_order: z55.array(z55.string().max(128)).max(64).optional(),
+var OhMyOpenCodeConfigSchema = z54.object({
+  $schema: z54.string().optional(),
+  new_task_system_enabled: z54.boolean().optional(),
+  default_run_agent: z54.string().optional(),
+  agent_order: z54.array(z54.string().max(128)).max(64).optional(),
   agent_definitions: AgentDefinitionsConfigSchema,
-  disabled_mcps: z55.array(AnyMcpNameSchema).optional(),
-  disabled_agents: z55.array(z55.string()).optional(),
-  disabled_skills: z55.array(z55.string()).optional(),
-  disabled_hooks: z55.array(z55.string()).optional(),
-  disabled_commands: z55.array(BuiltinCommandNameSchema).optional(),
-  disabled_tools: z55.array(z55.string()).optional(),
-  disabled_providers: z55.array(z55.string()).optional(),
-  mcp_env_allowlist: z55.array(z55.string()).optional(),
-  hashline_edit: z55.boolean().optional(),
-  telemetry: z55.boolean().optional().describe("Enable or disable anonymous telemetry. Default: enabled when omitted. Set to false to disable."),
-  model_fallback: z55.boolean().optional(),
+  disabled_mcps: z54.array(AnyMcpNameSchema).optional(),
+  disabled_agents: z54.array(z54.string()).optional(),
+  disabled_skills: z54.array(z54.string()).optional(),
+  disabled_hooks: z54.array(z54.string()).optional(),
+  disabled_commands: z54.array(BuiltinCommandNameSchema).optional(),
+  disabled_tools: z54.array(z54.string()).optional(),
+  disabled_providers: z54.array(z54.string()).optional(),
+  mcp_env_allowlist: z54.array(z54.string()).optional(),
+  hashline_edit: z54.boolean().optional(),
+  telemetry: z54.boolean().optional().describe("Enable or disable anonymous telemetry. Default: enabled when omitted. Set to false to disable."),
+  model_fallback: z54.boolean().optional(),
   agents: AgentOverridesSchema.optional(),
   categories: CategoriesConfigSchema.optional(),
   claude_code: ClaudeCodeConfigSchema.optional(),
   sisyphus_agent: SisyphusAgentConfigSchema.optional(),
   comment_checker: CommentCheckerConfigSchema.optional(),
   experimental: ExperimentalConfigSchema.optional(),
-  auto_update: z55.boolean().optional(),
+  auto_update: z54.boolean().optional(),
   skills: SkillsConfigSchema.optional(),
   goal: GoalConfigSchema.optional(),
-  ralph_loop: z55.record(z55.string(), z55.unknown()).optional(),
-  runtime_fallback: z55.union([z55.boolean(), RuntimeFallbackConfigSchema]).optional(),
+  ralph_loop: z54.record(z54.string(), z54.unknown()).optional(),
+  runtime_fallback: z54.union([z54.boolean(), RuntimeFallbackConfigSchema]).optional(),
   background_task: BackgroundTaskConfigSchema.optional(),
   notification: NotificationConfigSchema.optional(),
   model_capabilities: ModelCapabilitiesConfigSchema.optional(),
@@ -91767,7 +91731,7 @@ var OhMyOpenCodeConfigSchema = z55.object({
   ulw_execute: UlwExecuteConfigSchema.optional(),
   start_work: UlwExecuteConfigSchema.optional(),
   default_mode: DefaultModeConfigSchema.optional(),
-  _migrations: z55.array(z55.string()).optional()
+  _migrations: z54.array(z54.string()).optional()
 });
 // packages/omo-opencode/src/config/prune-plugin-view.ts
 var validatePluginRecord = (record) => {
@@ -95481,7 +95445,7 @@ function parseRuleFrontmatter2(content) {
 }
 // packages/rules-engine/src/matcher.ts
 var import_picomatch2 = __toESM(require_picomatch2(), 1);
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { basename as basename13, relative as relative11 } from "path";
 var matcherCache = new Map;
 var MAX_MATCHER_CACHE_ENTRIES = 256;
@@ -95510,7 +95474,7 @@ function shouldApplyRule(metadata, currentFilePath, projectRoot) {
   return { applies: false };
 }
 function createContentHash(content) {
-  return createHash3("sha256").update(content).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(content).digest("hex").slice(0, 16);
 }
 function isDuplicateByRealPath(realPath, cache) {
   return cache.has(realPath);
@@ -103248,7 +103212,6 @@ function transformSubscriptionProviderRename(document) {
 }
 
 // packages/omo-opencode/src/config-migration/migration-plans.ts
-var DORI_SECTION_RENAME_MIGRATION_ID = "2026-10-dori-section-rename";
 function backupTimestamp(value) {
   return value ?? new Date().toISOString().replace(/[:.]/g, "-");
 }
@@ -103350,18 +103313,6 @@ function subscriptionProviderRenamePlan(targetPath) {
     transform: inspect
   };
 }
-function doriSectionRenamePlan(targetPath, rename) {
-  const inspect = (sources) => rename.transform(sources[0]?.value);
-  return {
-    id: DORI_SECTION_RENAME_MIGRATION_ID,
-    inspect,
-    mode: "replace-target",
-    shouldRun: rename.shouldRun,
-    sources: [],
-    targetPath,
-    transform: inspect
-  };
-}
 function existingOmoConfigPath(directory, options) {
   const fileSystem = discoveryFileSystem(options);
   for (const fileName of ["omo.jsonc", "omo.json"]) {
@@ -103423,7 +103374,6 @@ function createLegacyConfigMigrationPlans(options) {
     addReasoningTarget(plan.targetPath);
   const inPlaceTargets = [...reasoningTargets.values()];
   return [
-    ...inPlaceTargets.map((targetPath) => doriSectionRenamePlan(targetPath, options.doriSectionRename)),
     ...legacyPlans,
     ...inPlaceTargets.map(reasoningPlan),
     ...inPlaceTargets.map(categoryDeepSplitPlan),
@@ -103431,12 +103381,6 @@ function createLegacyConfigMigrationPlans(options) {
     ...inPlaceTargets.map(subscriptionProviderRenamePlan)
   ];
 }
-// packages/omo-opencode/src/config-migration/dori-section-rename.ts
-var doriSectionRename = {
-  shouldRun: hasLegacyGatewaySection,
-  transform: migrateLegacyDoriSection
-};
-
 // packages/omo-opencode/src/startup-migration.ts
 function homeDirectory(options) {
   const environment = options.environment ?? process.env;
@@ -103475,7 +103419,6 @@ function runOpenCodeStartupMigration(options) {
         ...options.backupTimestamp === undefined ? {} : { backupTimestamp: options.backupTimestamp },
         cwd: options.cwd,
         ...options.discoveryFileSystem === undefined ? {} : { fileSystem: options.discoveryFileSystem },
-        doriSectionRename,
         environment: options.environment ?? process.env,
         homeDir,
         pathOperations: options.pathOperations ?? posix8,
@@ -111136,35 +111079,35 @@ import { mkdirSync as mkdirSync18, readFileSync as readFileSync48, renameSync as
 import { join as join96 } from "path";
 
 // packages/omo-opencode/src/hooks/goal/types.ts
-import { z as z57 } from "zod";
+import { z as z56 } from "zod";
 var GOAL_STATUS_VALUES = ["active", "paused", "complete"];
-var GoalStatusSchema = z57.enum(GOAL_STATUS_VALUES);
-var GoalSchema = z57.object({
-  id: z57.string(),
-  sessionID: z57.string(),
-  objective: z57.string(),
+var GoalStatusSchema = z56.enum(GOAL_STATUS_VALUES);
+var GoalSchema = z56.object({
+  id: z56.string(),
+  sessionID: z56.string(),
+  objective: z56.string(),
   status: GoalStatusSchema,
-  tokensUsed: z57.number().int().nonnegative(),
-  timeUsedSeconds: z57.number().int().nonnegative(),
-  createdAt: z57.number().int().nonnegative(),
-  updatedAt: z57.number().int().nonnegative(),
-  lastStartedAt: z57.number().int().nonnegative().optional(),
-  completedAt: z57.number().int().nonnegative().optional()
+  tokensUsed: z56.number().int().nonnegative(),
+  timeUsedSeconds: z56.number().int().nonnegative(),
+  createdAt: z56.number().int().nonnegative(),
+  updatedAt: z56.number().int().nonnegative(),
+  lastStartedAt: z56.number().int().nonnegative().optional(),
+  completedAt: z56.number().int().nonnegative().optional()
 });
-var GoalFileSchema = z57.object({
-  version: z57.literal(1),
+var GoalFileSchema = z56.object({
+  version: z56.literal(1),
   goal: GoalSchema.nullable()
 });
-var GoalToolSnapshotSchema = z57.object({
-  sessionID: z57.string(),
-  objective: z57.string(),
+var GoalToolSnapshotSchema = z56.object({
+  sessionID: z56.string(),
+  objective: z56.string(),
   status: GoalStatusSchema,
-  tokensUsed: z57.number().int().nonnegative(),
-  timeUsedSeconds: z57.number().int().nonnegative(),
-  createdAt: z57.number().int().nonnegative(),
-  updatedAt: z57.number().int().nonnegative()
+  tokensUsed: z56.number().int().nonnegative(),
+  timeUsedSeconds: z56.number().int().nonnegative(),
+  createdAt: z56.number().int().nonnegative(),
+  updatedAt: z56.number().int().nonnegative()
 });
-var GoalToolResponseSchema = z57.object({
+var GoalToolResponseSchema = z56.object({
   goal: GoalToolSnapshotSchema.nullable()
 });
 
@@ -127972,11 +127915,11 @@ function createMonitorStatusInjectorHook(monitorManager, config) {
 import { resolve as resolve29 } from "path";
 
 // node_modules/.bun/@opencode-ai+plugin@1.18.31+7445fc152a67980a/node_modules/@opencode-ai/plugin/dist/tool.js
-import { z as z58 } from "zod";
+import { z as z57 } from "zod";
 function tool(input) {
   return input;
 }
-tool.schema = z58;
+tool.schema = z57;
 
 // packages/omo-opencode/src/shared/ripgrep-cli.ts
 import { spawnSync as spawnSync2 } from "child_process";
@@ -135437,7 +135380,10 @@ function createSkillMcpTool(options) {
       switch (operation.type) {
         case "tool": {
           const result = await manager.callTool(info, context, operation.name, parsedArgs, cdpOptions);
-          output = JSON.stringify(result, null, 2);
+          if (result.isError === true) {
+            throw new Error(`MCP tool "${operation.name}" failed: ${JSON.stringify(result, null, 2)}`);
+          }
+          output = JSON.stringify(result.structuredContent !== undefined ? result : result.content, null, 2);
           break;
         }
         case "resource": {
@@ -142029,55 +141975,55 @@ function isExplicitSyncRun(runInBackground) {
 import { join as join127 } from "path";
 
 // packages/omo-opencode/src/tools/task/types.ts
-import { z as z59 } from "zod";
-var TaskStatusSchema = z59.enum(["pending", "in_progress", "completed", "deleted"]);
-var TaskObjectSchema = z59.object({
-  id: z59.string(),
-  subject: z59.string(),
-  description: z59.string(),
+import { z as z58 } from "zod";
+var TaskStatusSchema = z58.enum(["pending", "in_progress", "completed", "deleted"]);
+var TaskObjectSchema = z58.object({
+  id: z58.string(),
+  subject: z58.string(),
+  description: z58.string(),
   status: TaskStatusSchema,
-  activeForm: z59.string().optional(),
-  blocks: z59.array(z59.string()).default([]),
-  blockedBy: z59.array(z59.string()).default([]),
-  owner: z59.string().optional(),
-  metadata: z59.record(z59.string(), z59.unknown()).optional(),
-  repoURL: z59.string().optional(),
-  parentID: z59.string().optional(),
-  threadID: z59.string()
+  activeForm: z58.string().optional(),
+  blocks: z58.array(z58.string()).default([]),
+  blockedBy: z58.array(z58.string()).default([]),
+  owner: z58.string().optional(),
+  metadata: z58.record(z58.string(), z58.unknown()).optional(),
+  repoURL: z58.string().optional(),
+  parentID: z58.string().optional(),
+  threadID: z58.string()
 }).strict();
-var TaskCreateInputSchema = z59.object({
-  subject: z59.string(),
-  description: z59.string().optional(),
-  activeForm: z59.string().optional(),
-  blocks: z59.array(z59.string()).optional(),
-  blockedBy: z59.array(z59.string()).optional(),
-  owner: z59.string().optional(),
-  metadata: z59.record(z59.string(), z59.unknown()).optional(),
-  repoURL: z59.string().optional(),
-  parentID: z59.string().optional()
+var TaskCreateInputSchema = z58.object({
+  subject: z58.string(),
+  description: z58.string().optional(),
+  activeForm: z58.string().optional(),
+  blocks: z58.array(z58.string()).optional(),
+  blockedBy: z58.array(z58.string()).optional(),
+  owner: z58.string().optional(),
+  metadata: z58.record(z58.string(), z58.unknown()).optional(),
+  repoURL: z58.string().optional(),
+  parentID: z58.string().optional()
 });
-var TaskListInputSchema = z59.object({
+var TaskListInputSchema = z58.object({
   status: TaskStatusSchema.optional(),
-  parentID: z59.string().optional()
+  parentID: z58.string().optional()
 });
-var TaskGetInputSchema = z59.object({
-  id: z59.string()
+var TaskGetInputSchema = z58.object({
+  id: z58.string()
 });
-var TaskUpdateInputSchema = z59.object({
-  id: z59.string(),
-  subject: z59.string().optional(),
-  description: z59.string().optional(),
+var TaskUpdateInputSchema = z58.object({
+  id: z58.string(),
+  subject: z58.string().optional(),
+  description: z58.string().optional(),
   status: TaskStatusSchema.optional(),
-  activeForm: z59.string().optional(),
-  addBlocks: z59.array(z59.string()).optional(),
-  addBlockedBy: z59.array(z59.string()).optional(),
-  owner: z59.string().optional(),
-  metadata: z59.record(z59.string(), z59.unknown()).optional(),
-  repoURL: z59.string().optional(),
-  parentID: z59.string().optional()
+  activeForm: z58.string().optional(),
+  addBlocks: z58.array(z58.string()).optional(),
+  addBlockedBy: z58.array(z58.string()).optional(),
+  owner: z58.string().optional(),
+  metadata: z58.record(z58.string(), z58.unknown()).optional(),
+  repoURL: z58.string().optional(),
+  parentID: z58.string().optional()
 });
-var TaskDeleteInputSchema = z59.object({
-  id: z59.string()
+var TaskDeleteInputSchema = z58.object({
+  id: z58.string()
 });
 
 // packages/omo-opencode/src/features/claude-tasks/storage.ts
@@ -142978,7 +142924,7 @@ function createHashlineEditTool(ctx) {
 // packages/omo-opencode/src/features/team-mode/tools/messaging.ts
 import { randomUUID as randomUUID11 } from "crypto";
 init_logger2();
-import { z as z60 } from "zod";
+import { z as z59 } from "zod";
 
 // packages/team-core/src/team-mailbox/send.ts
 init_paths();
@@ -143559,18 +143505,18 @@ async function resolveTeamRuntimeDetails(teamRunId, sessionID, config, deps) {
 
 // packages/omo-opencode/src/features/team-mode/tools/messaging.ts
 var MESSAGE_TOOL_KINDS = ["message", "announcement"];
-var TeamReferenceArgsSchema = z60.object({
-  path: z60.string().min(1),
-  description: z60.string().optional()
+var TeamReferenceArgsSchema = z59.object({
+  path: z59.string().min(1),
+  description: z59.string().optional()
 });
-var TeamSendMessageArgsSchema = z60.object({
-  teamRunId: z60.string().min(1),
-  to: z60.string().min(1),
-  body: z60.string(),
-  kind: z60.enum(MESSAGE_TOOL_KINDS).optional(),
-  correlationId: z60.preprocess((value) => value === "" ? undefined : value, z60.uuid().optional()),
-  summary: z60.string().optional(),
-  references: z60.array(TeamReferenceArgsSchema).optional()
+var TeamSendMessageArgsSchema = z59.object({
+  teamRunId: z59.string().min(1),
+  to: z59.string().min(1),
+  body: z59.string(),
+  kind: z59.enum(MESSAGE_TOOL_KINDS).optional(),
+  correlationId: z59.preprocess((value) => value === "" ? undefined : value, z59.uuid().optional()),
+  summary: z59.string().optional(),
+  references: z59.array(TeamReferenceArgsSchema).optional()
 });
 function createTeamSendMessageTool(config, client, deps = defaultTeamSendMessageToolDeps) {
   return tool({
@@ -151602,7 +151548,7 @@ function createMonitorManager(options) {
   return new MonitorManager(options);
 }
 // packages/mcp-client-core/src/mcp-oauth/storage.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import {
   chmodSync as chmodSync4,
   existsSync as existsSync103,
@@ -151690,7 +151636,7 @@ function getMcpOauthStorageDir() {
   return join135(getOpenCodeCliConfigDir(), STORAGE_DIR_NAME);
 }
 function getMcpOauthServerHash(serverHost, resource) {
-  return createHash5("sha256").update(buildKey(serverHost, resource)).digest("hex").slice(0, 32);
+  return createHash6("sha256").update(buildKey(serverHost, resource)).digest("hex").slice(0, 32);
 }
 function getMcpOauthStoragePath(serverHost, resource) {
   return join135(getMcpOauthStorageDir(), `${getMcpOauthServerHash(serverHost, resource)}.json`);
@@ -151990,13 +151936,13 @@ async function findAvailablePort2(startPort = DEFAULT_PORT) {
 
 // packages/mcp-client-core/src/mcp-oauth/oauth-authorization-flow.ts
 import { spawn as spawn4 } from "child_process";
-import { createHash as createHash6, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash7, randomBytes as randomBytes2 } from "crypto";
 import { createServer as createServer2 } from "http";
 function generateCodeVerifier() {
   return randomBytes2(32).toString("base64url");
 }
 function generateCodeChallenge(verifier) {
-  return createHash6("sha256").update(verifier).digest("base64url");
+  return createHash7("sha256").update(verifier).digest("base64url");
 }
 function buildAuthorizationUrl(authorizationEndpoint, options) {
   const url = new URL(authorizationEndpoint);
@@ -152487,63 +152433,63 @@ function getLiteralValue(schema) {
 }
 
 // node_modules/.bun/@modelcontextprotocol+sdk@1.32.1/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
-import * as z61 from "zod/v4";
+import * as z60 from "zod/v4";
 var LATEST_PROTOCOL_VERSION = "2025-11-25";
 var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
 var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
 var JSONRPC_VERSION = "2.0";
-var AssertObjectSchema = z61.custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
-var ProgressTokenSchema = z61.union([z61.string(), z61.number().int()]);
-var CursorSchema = z61.string();
-var TaskCreationParamsSchema = z61.looseObject({
-  ttl: z61.number().optional(),
-  pollInterval: z61.number().optional()
+var AssertObjectSchema = z60.custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
+var ProgressTokenSchema = z60.union([z60.string(), z60.number().int()]);
+var CursorSchema = z60.string();
+var TaskCreationParamsSchema = z60.looseObject({
+  ttl: z60.number().optional(),
+  pollInterval: z60.number().optional()
 });
-var TaskMetadataSchema = z61.object({
-  ttl: z61.number().optional()
+var TaskMetadataSchema = z60.object({
+  ttl: z60.number().optional()
 });
-var RelatedTaskMetadataSchema = z61.object({
-  taskId: z61.string()
+var RelatedTaskMetadataSchema = z60.object({
+  taskId: z60.string()
 });
-var RequestMetaSchema = z61.looseObject({
+var RequestMetaSchema = z60.looseObject({
   progressToken: ProgressTokenSchema.optional(),
   [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
 });
-var BaseRequestParamsSchema = z61.object({
+var BaseRequestParamsSchema = z60.object({
   _meta: RequestMetaSchema.optional()
 });
 var TaskAugmentedRequestParamsSchema = BaseRequestParamsSchema.extend({
   task: TaskMetadataSchema.optional()
 });
 var isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success;
-var RequestSchema = z61.object({
-  method: z61.string(),
+var RequestSchema = z60.object({
+  method: z60.string(),
   params: BaseRequestParamsSchema.loose().optional()
 });
-var NotificationsParamsSchema = z61.object({
+var NotificationsParamsSchema = z60.object({
   _meta: RequestMetaSchema.optional()
 });
-var NotificationSchema = z61.object({
-  method: z61.string(),
+var NotificationSchema = z60.object({
+  method: z60.string(),
   params: NotificationsParamsSchema.loose().optional()
 });
-var ResultSchema = z61.looseObject({
+var ResultSchema = z60.looseObject({
   _meta: RequestMetaSchema.optional()
 });
-var RequestIdSchema = z61.union([z61.string(), z61.number().int()]);
-var JSONRPCRequestSchema = z61.object({
-  jsonrpc: z61.literal(JSONRPC_VERSION),
+var RequestIdSchema = z60.union([z60.string(), z60.number().int()]);
+var JSONRPCRequestSchema = z60.object({
+  jsonrpc: z60.literal(JSONRPC_VERSION),
   id: RequestIdSchema,
   ...RequestSchema.shape
 }).strict();
 var isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success;
-var JSONRPCNotificationSchema = z61.object({
-  jsonrpc: z61.literal(JSONRPC_VERSION),
+var JSONRPCNotificationSchema = z60.object({
+  jsonrpc: z60.literal(JSONRPC_VERSION),
   ...NotificationSchema.shape
 }).strict();
 var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
-var JSONRPCResultResponseSchema = z61.object({
-  jsonrpc: z61.literal(JSONRPC_VERSION),
+var JSONRPCResultResponseSchema = z60.object({
+  jsonrpc: z60.literal(JSONRPC_VERSION),
   id: RequestIdSchema,
   result: ResultSchema
 }).strict();
@@ -152559,153 +152505,153 @@ var ErrorCode;
   ErrorCode[ErrorCode["InternalError"] = -32603] = "InternalError";
   ErrorCode[ErrorCode["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
 })(ErrorCode || (ErrorCode = {}));
-var JSONRPCErrorResponseSchema = z61.object({
-  jsonrpc: z61.literal(JSONRPC_VERSION),
+var JSONRPCErrorResponseSchema = z60.object({
+  jsonrpc: z60.literal(JSONRPC_VERSION),
   id: RequestIdSchema.optional(),
-  error: z61.object({
-    code: z61.number().int(),
-    message: z61.string(),
-    data: z61.unknown().optional()
+  error: z60.object({
+    code: z60.number().int(),
+    message: z60.string(),
+    data: z60.unknown().optional()
   })
 }).strict();
 var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
-var JSONRPCMessageSchema = z61.union([
+var JSONRPCMessageSchema = z60.union([
   JSONRPCRequestSchema,
   JSONRPCNotificationSchema,
   JSONRPCResultResponseSchema,
   JSONRPCErrorResponseSchema
 ]);
-var JSONRPCResponseSchema = z61.union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
+var JSONRPCResponseSchema = z60.union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
 var EmptyResultSchema = ResultSchema.strict();
 var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
   requestId: RequestIdSchema.optional(),
-  reason: z61.string().optional()
+  reason: z60.string().optional()
 });
 var CancelledNotificationSchema = NotificationSchema.extend({
-  method: z61.literal("notifications/cancelled"),
+  method: z60.literal("notifications/cancelled"),
   params: CancelledNotificationParamsSchema
 });
-var IconSchema = z61.object({
-  src: z61.string(),
-  mimeType: z61.string().optional(),
-  sizes: z61.array(z61.string()).optional(),
-  theme: z61.enum(["light", "dark"]).optional()
+var IconSchema = z60.object({
+  src: z60.string(),
+  mimeType: z60.string().optional(),
+  sizes: z60.array(z60.string()).optional(),
+  theme: z60.enum(["light", "dark"]).optional()
 });
-var IconsSchema = z61.object({
-  icons: z61.array(IconSchema).optional()
+var IconsSchema = z60.object({
+  icons: z60.array(IconSchema).optional()
 });
-var BaseMetadataSchema = z61.object({
-  name: z61.string(),
-  title: z61.string().optional()
+var BaseMetadataSchema = z60.object({
+  name: z60.string(),
+  title: z60.string().optional()
 });
 var ImplementationSchema = BaseMetadataSchema.extend({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
-  version: z61.string(),
-  websiteUrl: z61.string().optional(),
-  description: z61.string().optional()
+  version: z60.string(),
+  websiteUrl: z60.string().optional(),
+  description: z60.string().optional()
 });
-var FormElicitationCapabilitySchema = z61.intersection(z61.object({
-  applyDefaults: z61.boolean().optional()
-}), z61.record(z61.string(), z61.unknown()));
-var ElicitationCapabilitySchema = z61.preprocess((value) => {
+var FormElicitationCapabilitySchema = z60.intersection(z60.object({
+  applyDefaults: z60.boolean().optional()
+}), z60.record(z60.string(), z60.unknown()));
+var ElicitationCapabilitySchema = z60.preprocess((value) => {
   if (value && typeof value === "object" && !Array.isArray(value)) {
     if (Object.keys(value).length === 0) {
       return { form: {} };
     }
   }
   return value;
-}, z61.intersection(z61.object({
+}, z60.intersection(z60.object({
   form: FormElicitationCapabilitySchema.optional(),
   url: AssertObjectSchema.optional()
-}), z61.record(z61.string(), z61.unknown()).optional()));
-var ClientTasksCapabilitySchema = z61.looseObject({
+}), z60.record(z60.string(), z60.unknown()).optional()));
+var ClientTasksCapabilitySchema = z60.looseObject({
   list: AssertObjectSchema.optional(),
   cancel: AssertObjectSchema.optional(),
-  requests: z61.looseObject({
-    sampling: z61.looseObject({
+  requests: z60.looseObject({
+    sampling: z60.looseObject({
       createMessage: AssertObjectSchema.optional()
     }).optional(),
-    elicitation: z61.looseObject({
+    elicitation: z60.looseObject({
       create: AssertObjectSchema.optional()
     }).optional()
   }).optional()
 });
-var ServerTasksCapabilitySchema = z61.looseObject({
+var ServerTasksCapabilitySchema = z60.looseObject({
   list: AssertObjectSchema.optional(),
   cancel: AssertObjectSchema.optional(),
-  requests: z61.looseObject({
-    tools: z61.looseObject({
+  requests: z60.looseObject({
+    tools: z60.looseObject({
       call: AssertObjectSchema.optional()
     }).optional()
   }).optional()
 });
-var ClientCapabilitiesSchema = z61.object({
-  experimental: z61.record(z61.string(), AssertObjectSchema).optional(),
-  sampling: z61.object({
+var ClientCapabilitiesSchema = z60.object({
+  experimental: z60.record(z60.string(), AssertObjectSchema).optional(),
+  sampling: z60.object({
     context: AssertObjectSchema.optional(),
     tools: AssertObjectSchema.optional()
   }).optional(),
   elicitation: ElicitationCapabilitySchema.optional(),
-  roots: z61.object({
-    listChanged: z61.boolean().optional()
+  roots: z60.object({
+    listChanged: z60.boolean().optional()
   }).optional(),
   tasks: ClientTasksCapabilitySchema.optional(),
-  extensions: z61.record(z61.string(), AssertObjectSchema).optional()
+  extensions: z60.record(z60.string(), AssertObjectSchema).optional()
 });
 var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
-  protocolVersion: z61.string(),
+  protocolVersion: z60.string(),
   capabilities: ClientCapabilitiesSchema,
   clientInfo: ImplementationSchema
 });
 var InitializeRequestSchema = RequestSchema.extend({
-  method: z61.literal("initialize"),
+  method: z60.literal("initialize"),
   params: InitializeRequestParamsSchema
 });
-var ServerCapabilitiesSchema = z61.object({
-  experimental: z61.record(z61.string(), AssertObjectSchema).optional(),
+var ServerCapabilitiesSchema = z60.object({
+  experimental: z60.record(z60.string(), AssertObjectSchema).optional(),
   logging: AssertObjectSchema.optional(),
   completions: AssertObjectSchema.optional(),
-  prompts: z61.object({
-    listChanged: z61.boolean().optional()
+  prompts: z60.object({
+    listChanged: z60.boolean().optional()
   }).optional(),
-  resources: z61.object({
-    subscribe: z61.boolean().optional(),
-    listChanged: z61.boolean().optional()
+  resources: z60.object({
+    subscribe: z60.boolean().optional(),
+    listChanged: z60.boolean().optional()
   }).optional(),
-  tools: z61.object({
-    listChanged: z61.boolean().optional()
+  tools: z60.object({
+    listChanged: z60.boolean().optional()
   }).optional(),
   tasks: ServerTasksCapabilitySchema.optional(),
-  extensions: z61.record(z61.string(), AssertObjectSchema).optional()
+  extensions: z60.record(z60.string(), AssertObjectSchema).optional()
 });
 var InitializeResultSchema = ResultSchema.extend({
-  protocolVersion: z61.string(),
+  protocolVersion: z60.string(),
   capabilities: ServerCapabilitiesSchema,
   serverInfo: ImplementationSchema,
-  instructions: z61.string().optional()
+  instructions: z60.string().optional()
 });
 var InitializedNotificationSchema = NotificationSchema.extend({
-  method: z61.literal("notifications/initialized"),
+  method: z60.literal("notifications/initialized"),
   params: NotificationsParamsSchema.optional()
 });
 var isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success;
 var PingRequestSchema = RequestSchema.extend({
-  method: z61.literal("ping"),
+  method: z60.literal("ping"),
   params: BaseRequestParamsSchema.optional()
 });
-var ProgressSchema = z61.object({
-  progress: z61.number(),
-  total: z61.optional(z61.number()),
-  message: z61.optional(z61.string())
+var ProgressSchema = z60.object({
+  progress: z60.number(),
+  total: z60.optional(z60.number()),
+  message: z60.optional(z60.string())
 });
-var ProgressNotificationParamsSchema = z61.object({
+var ProgressNotificationParamsSchema = z60.object({
   ...NotificationsParamsSchema.shape,
   ...ProgressSchema.shape,
   progressToken: ProgressTokenSchema
 });
 var ProgressNotificationSchema = NotificationSchema.extend({
-  method: z61.literal("notifications/progress"),
+  method: z60.literal("notifications/progress"),
   params: ProgressNotificationParamsSchema
 });
 var PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({
@@ -152717,60 +152663,60 @@ var PaginatedRequestSchema = RequestSchema.extend({
 var PaginatedResultSchema = ResultSchema.extend({
   nextCursor: CursorSchema.optional()
 });
-var TaskStatusSchema2 = z61.enum(["working", "input_required", "completed", "failed", "cancelled"]);
-var TaskSchema2 = z61.object({
-  taskId: z61.string(),
+var TaskStatusSchema2 = z60.enum(["working", "input_required", "completed", "failed", "cancelled"]);
+var TaskSchema2 = z60.object({
+  taskId: z60.string(),
   status: TaskStatusSchema2,
-  ttl: z61.union([z61.number(), z61.null()]),
-  createdAt: z61.string(),
-  lastUpdatedAt: z61.string(),
-  pollInterval: z61.optional(z61.number()),
-  statusMessage: z61.optional(z61.string())
+  ttl: z60.union([z60.number(), z60.null()]),
+  createdAt: z60.string(),
+  lastUpdatedAt: z60.string(),
+  pollInterval: z60.optional(z60.number()),
+  statusMessage: z60.optional(z60.string())
 });
 var CreateTaskResultSchema = ResultSchema.extend({
   task: TaskSchema2
 });
 var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema2);
 var TaskStatusNotificationSchema = NotificationSchema.extend({
-  method: z61.literal("notifications/tasks/status"),
+  method: z60.literal("notifications/tasks/status"),
   params: TaskStatusNotificationParamsSchema
 });
 var GetTaskRequestSchema = RequestSchema.extend({
-  method: z61.literal("tasks/get"),
+  method: z60.literal("tasks/get"),
   params: BaseRequestParamsSchema.extend({
-    taskId: z61.string()
+    taskId: z60.string()
   })
 });
 var GetTaskResultSchema = ResultSchema.merge(TaskSchema2);
 var GetTaskPayloadRequestSchema = RequestSchema.extend({
-  method: z61.literal("tasks/result"),
+  method: z60.literal("tasks/result"),
   params: BaseRequestParamsSchema.extend({
-    taskId: z61.string()
+    taskId: z60.string()
   })
 });
 var GetTaskPayloadResultSchema = ResultSchema.loose();
 var ListTasksRequestSchema = PaginatedRequestSchema.extend({
-  method: z61.literal("tasks/list")
+  method: z60.literal("tasks/list")
 });
 var ListTasksResultSchema = PaginatedResultSchema.extend({
-  tasks: z61.array(TaskSchema2)
+  tasks: z60.array(TaskSchema2)
 });
 var CancelTaskRequestSchema = RequestSchema.extend({
-  method: z61.literal("tasks/cancel"),
+  method: z60.literal("tasks/cancel"),
   params: BaseRequestParamsSchema.extend({
-    taskId: z61.string()
+    taskId: z60.string()
   })
 });
 var CancelTaskResultSchema = ResultSchema.merge(TaskSchema2);
-var ResourceContentsSchema = z61.object({
-  uri: z61.string(),
-  mimeType: z61.optional(z61.string()),
-  _meta: z61.record(z61.string(), z61.unknown()).optional()
+var ResourceContentsSchema = z60.object({
+  uri: z60.string(),
+  mimeType: z60.optional(z60.string()),
+  _meta: z60.record(z60.string(), z60.unknown()).optional()
 });
 var TextResourceContentsSchema = ResourceContentsSchema.extend({
-  text: z61.string()
+  text: z60.string()
 });
-var Base64Schema = z61.string().refine((val) => {
+var Base64Schema = z60.string().refine((val) => {
   try {
     atob(val);
     return true;
@@ -152781,447 +152727,447 @@ var Base64Schema = z61.string().refine((val) => {
 var BlobResourceContentsSchema = ResourceContentsSchema.extend({
   blob: Base64Schema
 });
-var RoleSchema = z61.enum(["user", "assistant"]);
-var AnnotationsSchema = z61.object({
-  audience: z61.array(RoleSchema).optional(),
-  priority: z61.number().min(0).max(1).optional(),
-  lastModified: z61.iso.datetime({ offset: true }).optional()
+var RoleSchema = z60.enum(["user", "assistant"]);
+var AnnotationsSchema = z60.object({
+  audience: z60.array(RoleSchema).optional(),
+  priority: z60.number().min(0).max(1).optional(),
+  lastModified: z60.iso.datetime({ offset: true }).optional()
 });
-var ResourceSchema = z61.object({
+var ResourceSchema = z60.object({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
-  uri: z61.string(),
-  description: z61.optional(z61.string()),
-  mimeType: z61.optional(z61.string()),
-  size: z61.optional(z61.number()),
+  uri: z60.string(),
+  description: z60.optional(z60.string()),
+  mimeType: z60.optional(z60.string()),
+  size: z60.optional(z60.number()),
   annotations: AnnotationsSchema.optional(),
-  _meta: z61.optional(z61.looseObject({}))
+  _meta: z60.optional(z60.looseObject({}))
 });
-var ResourceTemplateSchema = z61.object({
+var ResourceTemplateSchema = z60.object({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
-  uriTemplate: z61.string(),
-  description: z61.optional(z61.string()),
-  mimeType: z61.optional(z61.string()),
+  uriTemplate: z60.string(),
+  description: z60.optional(z60.string()),
+  mimeType: z60.optional(z60.string()),
   annotations: AnnotationsSchema.optional(),
-  _meta: z61.optional(z61.looseObject({}))
+  _meta: z60.optional(z60.looseObject({}))
 });
 var ListResourcesRequestSchema = PaginatedRequestSchema.extend({
-  method: z61.literal("resources/list")
+  method: z60.literal("resources/list")
 });
 var ListResourcesResultSchema = PaginatedResultSchema.extend({
-  resources: z61.array(ResourceSchema)
+  resources: z60.array(ResourceSchema)
 });
 var ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({
-  method: z61.literal("resources/templates/list")
+  method: z60.literal("resources/templates/list")
 });
 var ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({
-  resourceTemplates: z61.array(ResourceTemplateSchema)
+  resourceTemplates: z60.array(ResourceTemplateSchema)
 });
 var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({
-  uri: z61.string()
+  uri: z60.string()
 });
 var ReadResourceRequestParamsSchema = ResourceRequestParamsSchema;
 var ReadResourceRequestSchema = RequestSchema.extend({
-  method: z61.literal("resources/read"),
+  method: z60.literal("resources/read"),
   params: ReadResourceRequestParamsSchema
 });
 var ReadResourceResultSchema = ResultSchema.extend({
-  contents: z61.array(z61.union([TextResourceContentsSchema, BlobResourceContentsSchema]))
+  contents: z60.array(z60.union([TextResourceContentsSchema, BlobResourceContentsSchema]))
 });
 var ResourceListChangedNotificationSchema = NotificationSchema.extend({
-  method: z61.literal("notifications/resources/list_changed"),
+  method: z60.literal("notifications/resources/list_changed"),
   params: NotificationsParamsSchema.optional()
 });
 var SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
 var SubscribeRequestSchema = RequestSchema.extend({
-  method: z61.literal("resources/subscribe"),
+  method: z60.literal("resources/subscribe"),
   params: SubscribeRequestParamsSchema
 });
 var UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema;
 var UnsubscribeRequestSchema = RequestSchema.extend({
-  method: z61.literal("resources/unsubscribe"),
+  method: z60.literal("resources/unsubscribe"),
   params: UnsubscribeRequestParamsSchema
 });
 var ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({
-  uri: z61.string()
+  uri: z60.string()
 });
 var ResourceUpdatedNotificationSchema = NotificationSchema.extend({
-  method: z61.literal("notifications/resources/updated"),
+  method: z60.literal("notifications/resources/updated"),
   params: ResourceUpdatedNotificationParamsSchema
 });
-var PromptArgumentSchema = z61.object({
-  name: z61.string(),
-  description: z61.optional(z61.string()),
-  required: z61.optional(z61.boolean())
+var PromptArgumentSchema = z60.object({
+  name: z60.string(),
+  description: z60.optional(z60.string()),
+  required: z60.optional(z60.boolean())
 });
-var PromptSchema = z61.object({
+var PromptSchema = z60.object({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
-  description: z61.optional(z61.string()),
-  arguments: z61.optional(z61.array(PromptArgumentSchema)),
-  _meta: z61.optional(z61.looseObject({}))
+  description: z60.optional(z60.string()),
+  arguments: z60.optional(z60.array(PromptArgumentSchema)),
+  _meta: z60.optional(z60.looseObject({}))
 });
 var ListPromptsRequestSchema = PaginatedRequestSchema.extend({
-  method: z61.literal("prompts/list")
+  method: z60.literal("prompts/list")
 });
 var ListPromptsResultSchema = PaginatedResultSchema.extend({
-  prompts: z61.array(PromptSchema)
+  prompts: z60.array(PromptSchema)
 });
 var GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({
-  name: z61.string(),
-  arguments: z61.record(z61.string(), z61.string()).optional()
+  name: z60.string(),
+  arguments: z60.record(z60.string(), z60.string()).optional()
 });
 var GetPromptRequestSchema = RequestSchema.extend({
-  method: z61.literal("prompts/get"),
+  method: z60.literal("prompts/get"),
   params: GetPromptRequestParamsSchema
 });
-var TextContentSchema = z61.object({
-  type: z61.literal("text"),
-  text: z61.string(),
+var TextContentSchema = z60.object({
+  type: z60.literal("text"),
+  text: z60.string(),
   annotations: AnnotationsSchema.optional(),
-  _meta: z61.record(z61.string(), z61.unknown()).optional()
+  _meta: z60.record(z60.string(), z60.unknown()).optional()
 });
-var ImageContentSchema = z61.object({
-  type: z61.literal("image"),
+var ImageContentSchema = z60.object({
+  type: z60.literal("image"),
   data: Base64Schema,
-  mimeType: z61.string(),
+  mimeType: z60.string(),
   annotations: AnnotationsSchema.optional(),
-  _meta: z61.record(z61.string(), z61.unknown()).optional()
+  _meta: z60.record(z60.string(), z60.unknown()).optional()
 });
-var AudioContentSchema = z61.object({
-  type: z61.literal("audio"),
+var AudioContentSchema = z60.object({
+  type: z60.literal("audio"),
   data: Base64Schema,
-  mimeType: z61.string(),
+  mimeType: z60.string(),
   annotations: AnnotationsSchema.optional(),
-  _meta: z61.record(z61.string(), z61.unknown()).optional()
+  _meta: z60.record(z60.string(), z60.unknown()).optional()
 });
-var ToolUseContentSchema = z61.object({
-  type: z61.literal("tool_use"),
-  name: z61.string(),
-  id: z61.string(),
-  input: z61.record(z61.string(), z61.unknown()),
-  _meta: z61.record(z61.string(), z61.unknown()).optional()
+var ToolUseContentSchema = z60.object({
+  type: z60.literal("tool_use"),
+  name: z60.string(),
+  id: z60.string(),
+  input: z60.record(z60.string(), z60.unknown()),
+  _meta: z60.record(z60.string(), z60.unknown()).optional()
 });
-var EmbeddedResourceSchema = z61.object({
-  type: z61.literal("resource"),
-  resource: z61.union([TextResourceContentsSchema, BlobResourceContentsSchema]),
+var EmbeddedResourceSchema = z60.object({
+  type: z60.literal("resource"),
+  resource: z60.union([TextResourceContentsSchema, BlobResourceContentsSchema]),
   annotations: AnnotationsSchema.optional(),
-  _meta: z61.record(z61.string(), z61.unknown()).optional()
+  _meta: z60.record(z60.string(), z60.unknown()).optional()
 });
 var ResourceLinkSchema = ResourceSchema.extend({
-  type: z61.literal("resource_link")
+  type: z60.literal("resource_link")
 });
-var ContentBlockSchema = z61.union([
+var ContentBlockSchema = z60.union([
   TextContentSchema,
   ImageContentSchema,
   AudioContentSchema,
   ResourceLinkSchema,
   EmbeddedResourceSchema
 ]);
-var PromptMessageSchema = z61.object({
+var PromptMessageSchema = z60.object({
   role: RoleSchema,
   content: ContentBlockSchema
 });
 var GetPromptResultSchema = ResultSchema.extend({
-  description: z61.string().optional(),
-  messages: z61.array(PromptMessageSchema)
+  description: z60.string().optional(),
+  messages: z60.array(PromptMessageSchema)
 });
 var PromptListChangedNotificationSchema = NotificationSchema.extend({
-  method: z61.literal("notifications/prompts/list_changed"),
+  method: z60.literal("notifications/prompts/list_changed"),
   params: NotificationsParamsSchema.optional()
 });
-var ToolAnnotationsSchema = z61.object({
-  title: z61.string().optional(),
-  readOnlyHint: z61.boolean().optional(),
-  destructiveHint: z61.boolean().optional(),
-  idempotentHint: z61.boolean().optional(),
-  openWorldHint: z61.boolean().optional()
+var ToolAnnotationsSchema = z60.object({
+  title: z60.string().optional(),
+  readOnlyHint: z60.boolean().optional(),
+  destructiveHint: z60.boolean().optional(),
+  idempotentHint: z60.boolean().optional(),
+  openWorldHint: z60.boolean().optional()
 });
-var ToolExecutionSchema = z61.object({
-  taskSupport: z61.enum(["required", "optional", "forbidden"]).optional()
+var ToolExecutionSchema = z60.object({
+  taskSupport: z60.enum(["required", "optional", "forbidden"]).optional()
 });
-var ToolSchema = z61.object({
+var ToolSchema = z60.object({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
-  description: z61.string().optional(),
-  inputSchema: z61.object({
-    type: z61.literal("object"),
-    properties: z61.record(z61.string(), AssertObjectSchema).optional(),
-    required: z61.array(z61.string()).optional()
-  }).catchall(z61.unknown()),
-  outputSchema: z61.object({
-    type: z61.literal("object"),
-    properties: z61.record(z61.string(), AssertObjectSchema).optional(),
-    required: z61.array(z61.string()).optional()
-  }).catchall(z61.unknown()).optional(),
+  description: z60.string().optional(),
+  inputSchema: z60.object({
+    type: z60.literal("object"),
+    properties: z60.record(z60.string(), AssertObjectSchema).optional(),
+    required: z60.array(z60.string()).optional()
+  }).catchall(z60.unknown()),
+  outputSchema: z60.object({
+    type: z60.literal("object"),
+    properties: z60.record(z60.string(), AssertObjectSchema).optional(),
+    required: z60.array(z60.string()).optional()
+  }).catchall(z60.unknown()).optional(),
   annotations: ToolAnnotationsSchema.optional(),
   execution: ToolExecutionSchema.optional(),
-  _meta: z61.record(z61.string(), z61.unknown()).optional()
+  _meta: z60.record(z60.string(), z60.unknown()).optional()
 });
 var ListToolsRequestSchema = PaginatedRequestSchema.extend({
-  method: z61.literal("tools/list")
+  method: z60.literal("tools/list")
 });
 var ListToolsResultSchema = PaginatedResultSchema.extend({
-  tools: z61.array(ToolSchema)
+  tools: z60.array(ToolSchema)
 });
 var CallToolResultSchema = ResultSchema.extend({
-  content: z61.array(ContentBlockSchema).default([]),
-  structuredContent: z61.record(z61.string(), z61.unknown()).optional(),
-  isError: z61.boolean().optional()
+  content: z60.array(ContentBlockSchema).default([]),
+  structuredContent: z60.record(z60.string(), z60.unknown()).optional(),
+  isError: z60.boolean().optional()
 });
 var CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({
-  toolResult: z61.unknown()
+  toolResult: z60.unknown()
 }));
 var CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
-  name: z61.string(),
-  arguments: z61.record(z61.string(), z61.unknown()).optional()
+  name: z60.string(),
+  arguments: z60.record(z60.string(), z60.unknown()).optional()
 });
 var CallToolRequestSchema = RequestSchema.extend({
-  method: z61.literal("tools/call"),
+  method: z60.literal("tools/call"),
   params: CallToolRequestParamsSchema
 });
 var ToolListChangedNotificationSchema = NotificationSchema.extend({
-  method: z61.literal("notifications/tools/list_changed"),
+  method: z60.literal("notifications/tools/list_changed"),
   params: NotificationsParamsSchema.optional()
 });
-var ListChangedOptionsBaseSchema = z61.object({
-  autoRefresh: z61.boolean().default(true),
-  debounceMs: z61.number().int().nonnegative().default(300)
+var ListChangedOptionsBaseSchema = z60.object({
+  autoRefresh: z60.boolean().default(true),
+  debounceMs: z60.number().int().nonnegative().default(300)
 });
-var LoggingLevelSchema = z61.enum(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
+var LoggingLevelSchema = z60.enum(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
 var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({
   level: LoggingLevelSchema
 });
 var SetLevelRequestSchema = RequestSchema.extend({
-  method: z61.literal("logging/setLevel"),
+  method: z60.literal("logging/setLevel"),
   params: SetLevelRequestParamsSchema
 });
 var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({
   level: LoggingLevelSchema,
-  logger: z61.string().optional(),
-  data: z61.unknown()
+  logger: z60.string().optional(),
+  data: z60.unknown()
 });
 var LoggingMessageNotificationSchema = NotificationSchema.extend({
-  method: z61.literal("notifications/message"),
+  method: z60.literal("notifications/message"),
   params: LoggingMessageNotificationParamsSchema
 });
-var ModelHintSchema = z61.object({
-  name: z61.string().optional()
+var ModelHintSchema = z60.object({
+  name: z60.string().optional()
 });
-var ModelPreferencesSchema = z61.object({
-  hints: z61.array(ModelHintSchema).optional(),
-  costPriority: z61.number().min(0).max(1).optional(),
-  speedPriority: z61.number().min(0).max(1).optional(),
-  intelligencePriority: z61.number().min(0).max(1).optional()
+var ModelPreferencesSchema = z60.object({
+  hints: z60.array(ModelHintSchema).optional(),
+  costPriority: z60.number().min(0).max(1).optional(),
+  speedPriority: z60.number().min(0).max(1).optional(),
+  intelligencePriority: z60.number().min(0).max(1).optional()
 });
-var ToolChoiceSchema = z61.object({
-  mode: z61.enum(["auto", "required", "none"]).optional()
+var ToolChoiceSchema = z60.object({
+  mode: z60.enum(["auto", "required", "none"]).optional()
 });
-var ToolResultContentSchema = z61.object({
-  type: z61.literal("tool_result"),
-  toolUseId: z61.string().describe("The unique identifier for the corresponding tool call."),
-  content: z61.array(ContentBlockSchema).default([]),
-  structuredContent: z61.object({}).loose().optional(),
-  isError: z61.boolean().optional(),
-  _meta: z61.record(z61.string(), z61.unknown()).optional()
+var ToolResultContentSchema = z60.object({
+  type: z60.literal("tool_result"),
+  toolUseId: z60.string().describe("The unique identifier for the corresponding tool call."),
+  content: z60.array(ContentBlockSchema).default([]),
+  structuredContent: z60.object({}).loose().optional(),
+  isError: z60.boolean().optional(),
+  _meta: z60.record(z60.string(), z60.unknown()).optional()
 });
-var SamplingContentSchema = z61.discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
-var SamplingMessageContentBlockSchema = z61.discriminatedUnion("type", [
+var SamplingContentSchema = z60.discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
+var SamplingMessageContentBlockSchema = z60.discriminatedUnion("type", [
   TextContentSchema,
   ImageContentSchema,
   AudioContentSchema,
   ToolUseContentSchema,
   ToolResultContentSchema
 ]);
-var SamplingMessageSchema = z61.object({
+var SamplingMessageSchema = z60.object({
   role: RoleSchema,
-  content: z61.union([SamplingMessageContentBlockSchema, z61.array(SamplingMessageContentBlockSchema)]),
-  _meta: z61.record(z61.string(), z61.unknown()).optional()
+  content: z60.union([SamplingMessageContentBlockSchema, z60.array(SamplingMessageContentBlockSchema)]),
+  _meta: z60.record(z60.string(), z60.unknown()).optional()
 });
 var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
-  messages: z61.array(SamplingMessageSchema),
+  messages: z60.array(SamplingMessageSchema),
   modelPreferences: ModelPreferencesSchema.optional(),
-  systemPrompt: z61.string().optional(),
-  includeContext: z61.enum(["none", "thisServer", "allServers"]).optional(),
-  temperature: z61.number().optional(),
-  maxTokens: z61.number().int(),
-  stopSequences: z61.array(z61.string()).optional(),
+  systemPrompt: z60.string().optional(),
+  includeContext: z60.enum(["none", "thisServer", "allServers"]).optional(),
+  temperature: z60.number().optional(),
+  maxTokens: z60.number().int(),
+  stopSequences: z60.array(z60.string()).optional(),
   metadata: AssertObjectSchema.optional(),
-  tools: z61.array(ToolSchema).optional(),
+  tools: z60.array(ToolSchema).optional(),
   toolChoice: ToolChoiceSchema.optional()
 });
 var CreateMessageRequestSchema = RequestSchema.extend({
-  method: z61.literal("sampling/createMessage"),
+  method: z60.literal("sampling/createMessage"),
   params: CreateMessageRequestParamsSchema
 });
 var CreateMessageResultSchema = ResultSchema.extend({
-  model: z61.string(),
-  stopReason: z61.optional(z61.enum(["endTurn", "stopSequence", "maxTokens"]).or(z61.string())),
+  model: z60.string(),
+  stopReason: z60.optional(z60.enum(["endTurn", "stopSequence", "maxTokens"]).or(z60.string())),
   role: RoleSchema,
   content: SamplingContentSchema
 });
 var CreateMessageResultWithToolsSchema = ResultSchema.extend({
-  model: z61.string(),
-  stopReason: z61.optional(z61.enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(z61.string())),
+  model: z60.string(),
+  stopReason: z60.optional(z60.enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(z60.string())),
   role: RoleSchema,
-  content: z61.union([SamplingMessageContentBlockSchema, z61.array(SamplingMessageContentBlockSchema)])
+  content: z60.union([SamplingMessageContentBlockSchema, z60.array(SamplingMessageContentBlockSchema)])
 });
-var BooleanSchemaSchema = z61.object({
-  type: z61.literal("boolean"),
-  title: z61.string().optional(),
-  description: z61.string().optional(),
-  default: z61.boolean().optional()
+var BooleanSchemaSchema = z60.object({
+  type: z60.literal("boolean"),
+  title: z60.string().optional(),
+  description: z60.string().optional(),
+  default: z60.boolean().optional()
 });
-var StringSchemaSchema = z61.object({
-  type: z61.literal("string"),
-  title: z61.string().optional(),
-  description: z61.string().optional(),
-  minLength: z61.number().optional(),
-  maxLength: z61.number().optional(),
-  format: z61.enum(["email", "uri", "date", "date-time"]).optional(),
-  default: z61.string().optional()
+var StringSchemaSchema = z60.object({
+  type: z60.literal("string"),
+  title: z60.string().optional(),
+  description: z60.string().optional(),
+  minLength: z60.number().optional(),
+  maxLength: z60.number().optional(),
+  format: z60.enum(["email", "uri", "date", "date-time"]).optional(),
+  default: z60.string().optional()
 });
-var NumberSchemaSchema = z61.object({
-  type: z61.enum(["number", "integer"]),
-  title: z61.string().optional(),
-  description: z61.string().optional(),
-  minimum: z61.number().optional(),
-  maximum: z61.number().optional(),
-  default: z61.number().optional()
+var NumberSchemaSchema = z60.object({
+  type: z60.enum(["number", "integer"]),
+  title: z60.string().optional(),
+  description: z60.string().optional(),
+  minimum: z60.number().optional(),
+  maximum: z60.number().optional(),
+  default: z60.number().optional()
 });
-var UntitledSingleSelectEnumSchemaSchema = z61.object({
-  type: z61.literal("string"),
-  title: z61.string().optional(),
-  description: z61.string().optional(),
-  enum: z61.array(z61.string()),
-  default: z61.string().optional()
+var UntitledSingleSelectEnumSchemaSchema = z60.object({
+  type: z60.literal("string"),
+  title: z60.string().optional(),
+  description: z60.string().optional(),
+  enum: z60.array(z60.string()),
+  default: z60.string().optional()
 });
-var TitledSingleSelectEnumSchemaSchema = z61.object({
-  type: z61.literal("string"),
-  title: z61.string().optional(),
-  description: z61.string().optional(),
-  oneOf: z61.array(z61.object({
-    const: z61.string(),
-    title: z61.string()
+var TitledSingleSelectEnumSchemaSchema = z60.object({
+  type: z60.literal("string"),
+  title: z60.string().optional(),
+  description: z60.string().optional(),
+  oneOf: z60.array(z60.object({
+    const: z60.string(),
+    title: z60.string()
   })),
-  default: z61.string().optional()
+  default: z60.string().optional()
 });
-var LegacyTitledEnumSchemaSchema = z61.object({
-  type: z61.literal("string"),
-  title: z61.string().optional(),
-  description: z61.string().optional(),
-  enum: z61.array(z61.string()),
-  enumNames: z61.array(z61.string()).optional(),
-  default: z61.string().optional()
+var LegacyTitledEnumSchemaSchema = z60.object({
+  type: z60.literal("string"),
+  title: z60.string().optional(),
+  description: z60.string().optional(),
+  enum: z60.array(z60.string()),
+  enumNames: z60.array(z60.string()).optional(),
+  default: z60.string().optional()
 });
-var SingleSelectEnumSchemaSchema = z61.union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]);
-var UntitledMultiSelectEnumSchemaSchema = z61.object({
-  type: z61.literal("array"),
-  title: z61.string().optional(),
-  description: z61.string().optional(),
-  minItems: z61.number().optional(),
-  maxItems: z61.number().optional(),
-  items: z61.object({
-    type: z61.literal("string"),
-    enum: z61.array(z61.string())
+var SingleSelectEnumSchemaSchema = z60.union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]);
+var UntitledMultiSelectEnumSchemaSchema = z60.object({
+  type: z60.literal("array"),
+  title: z60.string().optional(),
+  description: z60.string().optional(),
+  minItems: z60.number().optional(),
+  maxItems: z60.number().optional(),
+  items: z60.object({
+    type: z60.literal("string"),
+    enum: z60.array(z60.string())
   }),
-  default: z61.array(z61.string()).optional()
+  default: z60.array(z60.string()).optional()
 });
-var TitledMultiSelectEnumSchemaSchema = z61.object({
-  type: z61.literal("array"),
-  title: z61.string().optional(),
-  description: z61.string().optional(),
-  minItems: z61.number().optional(),
-  maxItems: z61.number().optional(),
-  items: z61.object({
-    anyOf: z61.array(z61.object({
-      const: z61.string(),
-      title: z61.string()
+var TitledMultiSelectEnumSchemaSchema = z60.object({
+  type: z60.literal("array"),
+  title: z60.string().optional(),
+  description: z60.string().optional(),
+  minItems: z60.number().optional(),
+  maxItems: z60.number().optional(),
+  items: z60.object({
+    anyOf: z60.array(z60.object({
+      const: z60.string(),
+      title: z60.string()
     }))
   }),
-  default: z61.array(z61.string()).optional()
+  default: z60.array(z60.string()).optional()
 });
-var MultiSelectEnumSchemaSchema = z61.union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
-var EnumSchemaSchema = z61.union([LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema]);
-var PrimitiveSchemaDefinitionSchema = z61.union([EnumSchemaSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema]);
+var MultiSelectEnumSchemaSchema = z60.union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
+var EnumSchemaSchema = z60.union([LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema]);
+var PrimitiveSchemaDefinitionSchema = z60.union([EnumSchemaSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema]);
 var ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({
-  mode: z61.literal("form").optional(),
-  message: z61.string(),
-  requestedSchema: z61.object({
-    type: z61.literal("object"),
-    properties: z61.record(z61.string(), PrimitiveSchemaDefinitionSchema),
-    required: z61.array(z61.string()).optional()
+  mode: z60.literal("form").optional(),
+  message: z60.string(),
+  requestedSchema: z60.object({
+    type: z60.literal("object"),
+    properties: z60.record(z60.string(), PrimitiveSchemaDefinitionSchema),
+    required: z60.array(z60.string()).optional()
   })
 });
 var ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
-  mode: z61.literal("url"),
-  message: z61.string(),
-  elicitationId: z61.string(),
-  url: z61.string().url()
+  mode: z60.literal("url"),
+  message: z60.string(),
+  elicitationId: z60.string(),
+  url: z60.string().url()
 });
-var ElicitRequestParamsSchema = z61.union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]);
+var ElicitRequestParamsSchema = z60.union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]);
 var ElicitRequestSchema = RequestSchema.extend({
-  method: z61.literal("elicitation/create"),
+  method: z60.literal("elicitation/create"),
   params: ElicitRequestParamsSchema
 });
 var ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({
-  elicitationId: z61.string()
+  elicitationId: z60.string()
 });
 var ElicitationCompleteNotificationSchema = NotificationSchema.extend({
-  method: z61.literal("notifications/elicitation/complete"),
+  method: z60.literal("notifications/elicitation/complete"),
   params: ElicitationCompleteNotificationParamsSchema
 });
 var ElicitResultSchema = ResultSchema.extend({
-  action: z61.enum(["accept", "decline", "cancel"]),
-  content: z61.preprocess((val) => val === null ? undefined : val, z61.record(z61.string(), z61.union([z61.string(), z61.number(), z61.boolean(), z61.array(z61.string())])).optional())
+  action: z60.enum(["accept", "decline", "cancel"]),
+  content: z60.preprocess((val) => val === null ? undefined : val, z60.record(z60.string(), z60.union([z60.string(), z60.number(), z60.boolean(), z60.array(z60.string())])).optional())
 });
-var ResourceTemplateReferenceSchema = z61.object({
-  type: z61.literal("ref/resource"),
-  uri: z61.string()
+var ResourceTemplateReferenceSchema = z60.object({
+  type: z60.literal("ref/resource"),
+  uri: z60.string()
 });
-var PromptReferenceSchema = z61.object({
-  type: z61.literal("ref/prompt"),
-  name: z61.string()
+var PromptReferenceSchema = z60.object({
+  type: z60.literal("ref/prompt"),
+  name: z60.string()
 });
 var CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({
-  ref: z61.union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
-  argument: z61.object({
-    name: z61.string(),
-    value: z61.string()
+  ref: z60.union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
+  argument: z60.object({
+    name: z60.string(),
+    value: z60.string()
   }),
-  context: z61.object({
-    arguments: z61.record(z61.string(), z61.string()).optional()
+  context: z60.object({
+    arguments: z60.record(z60.string(), z60.string()).optional()
   }).optional()
 });
 var CompleteRequestSchema = RequestSchema.extend({
-  method: z61.literal("completion/complete"),
+  method: z60.literal("completion/complete"),
   params: CompleteRequestParamsSchema
 });
 var CompleteResultSchema = ResultSchema.extend({
-  completion: z61.looseObject({
-    values: z61.array(z61.string()).max(100),
-    total: z61.optional(z61.number().int()),
-    hasMore: z61.optional(z61.boolean())
+  completion: z60.looseObject({
+    values: z60.array(z60.string()).max(100),
+    total: z60.optional(z60.number().int()),
+    hasMore: z60.optional(z60.boolean())
   })
 });
-var RootSchema = z61.object({
-  uri: z61.string().startsWith("file://"),
-  name: z61.string().optional(),
-  _meta: z61.record(z61.string(), z61.unknown()).optional()
+var RootSchema = z60.object({
+  uri: z60.string().startsWith("file://"),
+  name: z60.string().optional(),
+  _meta: z60.record(z60.string(), z60.unknown()).optional()
 });
 var ListRootsRequestSchema = RequestSchema.extend({
-  method: z61.literal("roots/list"),
+  method: z60.literal("roots/list"),
   params: BaseRequestParamsSchema.optional()
 });
 var ListRootsResultSchema = ResultSchema.extend({
-  roots: z61.array(RootSchema)
+  roots: z60.array(RootSchema)
 });
 var RootsListChangedNotificationSchema = NotificationSchema.extend({
-  method: z61.literal("notifications/roots/list_changed"),
+  method: z60.literal("notifications/roots/list_changed"),
   params: NotificationsParamsSchema.optional()
 });
-var ClientRequestSchema = z61.union([
+var ClientRequestSchema = z60.union([
   PingRequestSchema,
   InitializeRequestSchema,
   CompleteRequestSchema,
@@ -153240,14 +153186,14 @@ var ClientRequestSchema = z61.union([
   ListTasksRequestSchema,
   CancelTaskRequestSchema
 ]);
-var ClientNotificationSchema = z61.union([
+var ClientNotificationSchema = z60.union([
   CancelledNotificationSchema,
   ProgressNotificationSchema,
   InitializedNotificationSchema,
   RootsListChangedNotificationSchema,
   TaskStatusNotificationSchema
 ]);
-var ClientResultSchema = z61.union([
+var ClientResultSchema = z60.union([
   EmptyResultSchema,
   CreateMessageResultSchema,
   CreateMessageResultWithToolsSchema,
@@ -153257,7 +153203,7 @@ var ClientResultSchema = z61.union([
   ListTasksResultSchema,
   CreateTaskResultSchema
 ]);
-var ServerRequestSchema = z61.union([
+var ServerRequestSchema = z60.union([
   PingRequestSchema,
   CreateMessageRequestSchema,
   ElicitRequestSchema,
@@ -153267,7 +153213,7 @@ var ServerRequestSchema = z61.union([
   ListTasksRequestSchema,
   CancelTaskRequestSchema
 ]);
-var ServerNotificationSchema = z61.union([
+var ServerNotificationSchema = z60.union([
   CancelledNotificationSchema,
   ProgressNotificationSchema,
   LoggingMessageNotificationSchema,
@@ -153278,7 +153224,7 @@ var ServerNotificationSchema = z61.union([
   TaskStatusNotificationSchema,
   ElicitationCompleteNotificationSchema
 ]);
-var ServerResultSchema = z61.union([
+var ServerResultSchema = z60.union([
   EmptyResultSchema,
   InitializeResultSchema,
   CompleteResultSchema,
@@ -155040,151 +154986,151 @@ async function pkceChallenge(length) {
 }
 
 // node_modules/.bun/@modelcontextprotocol+sdk@1.32.1/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
-import * as z62 from "zod/v4";
-var SafeUrlSchema = z62.url().superRefine((val, ctx) => {
+import * as z61 from "zod/v4";
+var SafeUrlSchema = z61.url().superRefine((val, ctx) => {
   if (!URL.canParse(val)) {
     ctx.addIssue({
-      code: z62.ZodIssueCode.custom,
+      code: z61.ZodIssueCode.custom,
       message: "URL must be parseable",
       fatal: true
     });
-    return z62.NEVER;
+    return z61.NEVER;
   }
 }).refine((url) => {
   const u = new URL(url);
   return u.protocol !== "javascript:" && u.protocol !== "data:" && u.protocol !== "vbscript:";
 }, { message: "URL cannot use javascript:, data:, or vbscript: scheme" });
-var OAuthProtectedResourceMetadataSchema = z62.looseObject({
-  resource: z62.string().url(),
-  authorization_servers: z62.array(SafeUrlSchema).optional(),
-  jwks_uri: z62.string().url().optional(),
-  scopes_supported: z62.array(z62.string()).optional(),
-  bearer_methods_supported: z62.array(z62.string()).optional(),
-  resource_signing_alg_values_supported: z62.array(z62.string()).optional(),
-  resource_name: z62.string().optional(),
-  resource_documentation: z62.string().optional(),
-  resource_policy_uri: z62.string().url().optional(),
-  resource_tos_uri: z62.string().url().optional(),
-  tls_client_certificate_bound_access_tokens: z62.boolean().optional(),
-  authorization_details_types_supported: z62.array(z62.string()).optional(),
-  dpop_signing_alg_values_supported: z62.array(z62.string()).optional(),
-  dpop_bound_access_tokens_required: z62.boolean().optional()
+var OAuthProtectedResourceMetadataSchema = z61.looseObject({
+  resource: z61.string().url(),
+  authorization_servers: z61.array(SafeUrlSchema).optional(),
+  jwks_uri: z61.string().url().optional(),
+  scopes_supported: z61.array(z61.string()).optional(),
+  bearer_methods_supported: z61.array(z61.string()).optional(),
+  resource_signing_alg_values_supported: z61.array(z61.string()).optional(),
+  resource_name: z61.string().optional(),
+  resource_documentation: z61.string().optional(),
+  resource_policy_uri: z61.string().url().optional(),
+  resource_tos_uri: z61.string().url().optional(),
+  tls_client_certificate_bound_access_tokens: z61.boolean().optional(),
+  authorization_details_types_supported: z61.array(z61.string()).optional(),
+  dpop_signing_alg_values_supported: z61.array(z61.string()).optional(),
+  dpop_bound_access_tokens_required: z61.boolean().optional()
 });
-var OAuthMetadataSchema = z62.looseObject({
-  issuer: z62.string(),
+var OAuthMetadataSchema = z61.looseObject({
+  issuer: z61.string(),
   authorization_endpoint: SafeUrlSchema,
   token_endpoint: SafeUrlSchema,
   registration_endpoint: SafeUrlSchema.optional(),
-  scopes_supported: z62.array(z62.string()).optional(),
-  response_types_supported: z62.array(z62.string()),
-  response_modes_supported: z62.array(z62.string()).optional(),
-  grant_types_supported: z62.array(z62.string()).optional(),
-  token_endpoint_auth_methods_supported: z62.array(z62.string()).optional(),
-  token_endpoint_auth_signing_alg_values_supported: z62.array(z62.string()).optional(),
+  scopes_supported: z61.array(z61.string()).optional(),
+  response_types_supported: z61.array(z61.string()),
+  response_modes_supported: z61.array(z61.string()).optional(),
+  grant_types_supported: z61.array(z61.string()).optional(),
+  token_endpoint_auth_methods_supported: z61.array(z61.string()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: z61.array(z61.string()).optional(),
   service_documentation: SafeUrlSchema.optional(),
   revocation_endpoint: SafeUrlSchema.optional(),
-  revocation_endpoint_auth_methods_supported: z62.array(z62.string()).optional(),
-  revocation_endpoint_auth_signing_alg_values_supported: z62.array(z62.string()).optional(),
-  introspection_endpoint: z62.string().optional(),
-  introspection_endpoint_auth_methods_supported: z62.array(z62.string()).optional(),
-  introspection_endpoint_auth_signing_alg_values_supported: z62.array(z62.string()).optional(),
-  code_challenge_methods_supported: z62.array(z62.string()).optional(),
-  client_id_metadata_document_supported: z62.boolean().optional()
+  revocation_endpoint_auth_methods_supported: z61.array(z61.string()).optional(),
+  revocation_endpoint_auth_signing_alg_values_supported: z61.array(z61.string()).optional(),
+  introspection_endpoint: z61.string().optional(),
+  introspection_endpoint_auth_methods_supported: z61.array(z61.string()).optional(),
+  introspection_endpoint_auth_signing_alg_values_supported: z61.array(z61.string()).optional(),
+  code_challenge_methods_supported: z61.array(z61.string()).optional(),
+  client_id_metadata_document_supported: z61.boolean().optional()
 });
-var OpenIdProviderMetadataSchema = z62.looseObject({
-  issuer: z62.string(),
+var OpenIdProviderMetadataSchema = z61.looseObject({
+  issuer: z61.string(),
   authorization_endpoint: SafeUrlSchema,
   token_endpoint: SafeUrlSchema,
   userinfo_endpoint: SafeUrlSchema.optional(),
   jwks_uri: SafeUrlSchema,
   registration_endpoint: SafeUrlSchema.optional(),
-  scopes_supported: z62.array(z62.string()).optional(),
-  response_types_supported: z62.array(z62.string()),
-  response_modes_supported: z62.array(z62.string()).optional(),
-  grant_types_supported: z62.array(z62.string()).optional(),
-  acr_values_supported: z62.array(z62.string()).optional(),
-  subject_types_supported: z62.array(z62.string()),
-  id_token_signing_alg_values_supported: z62.array(z62.string()),
-  id_token_encryption_alg_values_supported: z62.array(z62.string()).optional(),
-  id_token_encryption_enc_values_supported: z62.array(z62.string()).optional(),
-  userinfo_signing_alg_values_supported: z62.array(z62.string()).optional(),
-  userinfo_encryption_alg_values_supported: z62.array(z62.string()).optional(),
-  userinfo_encryption_enc_values_supported: z62.array(z62.string()).optional(),
-  request_object_signing_alg_values_supported: z62.array(z62.string()).optional(),
-  request_object_encryption_alg_values_supported: z62.array(z62.string()).optional(),
-  request_object_encryption_enc_values_supported: z62.array(z62.string()).optional(),
-  token_endpoint_auth_methods_supported: z62.array(z62.string()).optional(),
-  token_endpoint_auth_signing_alg_values_supported: z62.array(z62.string()).optional(),
-  display_values_supported: z62.array(z62.string()).optional(),
-  claim_types_supported: z62.array(z62.string()).optional(),
-  claims_supported: z62.array(z62.string()).optional(),
-  service_documentation: z62.string().optional(),
-  claims_locales_supported: z62.array(z62.string()).optional(),
-  ui_locales_supported: z62.array(z62.string()).optional(),
-  claims_parameter_supported: z62.boolean().optional(),
-  request_parameter_supported: z62.boolean().optional(),
-  request_uri_parameter_supported: z62.boolean().optional(),
-  require_request_uri_registration: z62.boolean().optional(),
+  scopes_supported: z61.array(z61.string()).optional(),
+  response_types_supported: z61.array(z61.string()),
+  response_modes_supported: z61.array(z61.string()).optional(),
+  grant_types_supported: z61.array(z61.string()).optional(),
+  acr_values_supported: z61.array(z61.string()).optional(),
+  subject_types_supported: z61.array(z61.string()),
+  id_token_signing_alg_values_supported: z61.array(z61.string()),
+  id_token_encryption_alg_values_supported: z61.array(z61.string()).optional(),
+  id_token_encryption_enc_values_supported: z61.array(z61.string()).optional(),
+  userinfo_signing_alg_values_supported: z61.array(z61.string()).optional(),
+  userinfo_encryption_alg_values_supported: z61.array(z61.string()).optional(),
+  userinfo_encryption_enc_values_supported: z61.array(z61.string()).optional(),
+  request_object_signing_alg_values_supported: z61.array(z61.string()).optional(),
+  request_object_encryption_alg_values_supported: z61.array(z61.string()).optional(),
+  request_object_encryption_enc_values_supported: z61.array(z61.string()).optional(),
+  token_endpoint_auth_methods_supported: z61.array(z61.string()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: z61.array(z61.string()).optional(),
+  display_values_supported: z61.array(z61.string()).optional(),
+  claim_types_supported: z61.array(z61.string()).optional(),
+  claims_supported: z61.array(z61.string()).optional(),
+  service_documentation: z61.string().optional(),
+  claims_locales_supported: z61.array(z61.string()).optional(),
+  ui_locales_supported: z61.array(z61.string()).optional(),
+  claims_parameter_supported: z61.boolean().optional(),
+  request_parameter_supported: z61.boolean().optional(),
+  request_uri_parameter_supported: z61.boolean().optional(),
+  require_request_uri_registration: z61.boolean().optional(),
   op_policy_uri: SafeUrlSchema.optional(),
   op_tos_uri: SafeUrlSchema.optional(),
-  client_id_metadata_document_supported: z62.boolean().optional()
+  client_id_metadata_document_supported: z61.boolean().optional()
 });
-var OpenIdProviderDiscoveryMetadataSchema = z62.object({
+var OpenIdProviderDiscoveryMetadataSchema = z61.object({
   ...OpenIdProviderMetadataSchema.shape,
   ...OAuthMetadataSchema.pick({
     code_challenge_methods_supported: true
   }).shape
 });
-var OAuthTokensSchema = z62.object({
-  access_token: z62.string(),
-  id_token: z62.string().optional(),
-  token_type: z62.string(),
-  expires_in: z62.coerce.number().optional(),
-  scope: z62.string().optional(),
-  refresh_token: z62.string().optional(),
-  issuer: z62.string().optional().catch(undefined)
+var OAuthTokensSchema = z61.object({
+  access_token: z61.string(),
+  id_token: z61.string().optional(),
+  token_type: z61.string(),
+  expires_in: z61.coerce.number().optional(),
+  scope: z61.string().optional(),
+  refresh_token: z61.string().optional(),
+  issuer: z61.string().optional().catch(undefined)
 }).strip();
-var OAuthErrorResponseSchema = z62.object({
-  error: z62.string(),
-  error_description: z62.string().optional(),
-  error_uri: z62.string().optional()
+var OAuthErrorResponseSchema = z61.object({
+  error: z61.string(),
+  error_description: z61.string().optional(),
+  error_uri: z61.string().optional()
 });
-var OptionalSafeUrlSchema = SafeUrlSchema.optional().or(z62.literal("").transform(() => {
+var OptionalSafeUrlSchema = SafeUrlSchema.optional().or(z61.literal("").transform(() => {
   return;
 }));
-var OAuthClientMetadataSchema = z62.object({
-  redirect_uris: z62.array(SafeUrlSchema),
-  token_endpoint_auth_method: z62.string().optional(),
-  grant_types: z62.array(z62.string()).optional(),
-  response_types: z62.array(z62.string()).optional(),
-  client_name: z62.string().optional(),
+var OAuthClientMetadataSchema = z61.object({
+  redirect_uris: z61.array(SafeUrlSchema),
+  token_endpoint_auth_method: z61.string().optional(),
+  grant_types: z61.array(z61.string()).optional(),
+  response_types: z61.array(z61.string()).optional(),
+  client_name: z61.string().optional(),
   client_uri: SafeUrlSchema.optional(),
   logo_uri: OptionalSafeUrlSchema,
-  scope: z62.string().optional(),
-  contacts: z62.array(z62.string()).optional(),
+  scope: z61.string().optional(),
+  contacts: z61.array(z61.string()).optional(),
   tos_uri: OptionalSafeUrlSchema,
-  policy_uri: z62.string().optional(),
+  policy_uri: z61.string().optional(),
   jwks_uri: SafeUrlSchema.optional(),
-  jwks: z62.any().optional(),
-  software_id: z62.string().optional(),
-  software_version: z62.string().optional(),
-  software_statement: z62.string().optional()
+  jwks: z61.any().optional(),
+  software_id: z61.string().optional(),
+  software_version: z61.string().optional(),
+  software_statement: z61.string().optional()
 }).strip();
-var OAuthClientInformationSchema = z62.object({
-  client_id: z62.string(),
-  client_secret: z62.string().optional(),
-  client_id_issued_at: z62.number().optional(),
-  client_secret_expires_at: z62.number().optional(),
-  issuer: z62.string().optional().catch(undefined)
+var OAuthClientInformationSchema = z61.object({
+  client_id: z61.string(),
+  client_secret: z61.string().optional(),
+  client_id_issued_at: z61.number().optional(),
+  client_secret_expires_at: z61.number().optional(),
+  issuer: z61.string().optional().catch(undefined)
 }).strip();
 var OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
-var OAuthClientRegistrationErrorSchema = z62.object({
-  error: z62.string(),
-  error_description: z62.string().optional()
+var OAuthClientRegistrationErrorSchema = z61.object({
+  error: z61.string(),
+  error_description: z61.string().optional()
 }).strip();
-var OAuthTokenRevocationRequestSchema = z62.object({
-  token: z62.string(),
-  token_type_hint: z62.string().optional()
+var OAuthTokenRevocationRequestSchema = z61.object({
+  token: z61.string(),
+  token_type_hint: z61.string().optional()
 }).strip();
 
 // node_modules/.bun/@modelcontextprotocol+sdk@1.32.1/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth-utils.js
@@ -157155,7 +157101,7 @@ import { resolve as resolve37 } from "path";
 
 // packages/mcp-client-core/src/skill-mcp-manager/env-grants-store.ts
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import { createHash as createHash7, randomUUID as randomUUID12 } from "crypto";
+import { createHash as createHash8, randomUUID as randomUUID12 } from "crypto";
 import { watch } from "fs";
 import { mkdir as mkdir6, open as open3, rename as rename4, rm as rm4, stat as stat9 } from "fs/promises";
 import { homedir as homedir28 } from "os";
@@ -157167,15 +157113,15 @@ var digestPattern = /^[a-f0-9]{64}$/;
 function resolveGrantsStorePath(configDir) {
   return join136(resolve36(configDir ?? join136(process.env.XDG_CONFIG_HOME ?? join136(homedir28(), ".config"), "omo")), "mcp-env-grants.json");
 }
-function record16(value) {
+function record15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parse5(value) {
-  if (!record16(value) || value.version !== 1 || !Number.isSafeInteger(value.generation) || typeof value.generation !== "number" || value.generation < 0 || !record16(value.grants))
+  if (!record15(value) || value.version !== 1 || !Number.isSafeInteger(value.generation) || typeof value.generation !== "number" || value.generation < 0 || !record15(value.grants))
     return;
   const grants = {};
   for (const [digest, entry] of Object.entries(value.grants)) {
-    if (!digestPattern.test(digest) || !record16(entry) || !record16(entry.label) || !Array.isArray(entry.names))
+    if (!digestPattern.test(digest) || !record15(entry) || !record15(entry.label) || !Array.isArray(entry.names))
       return;
     const { project, skill, server } = entry.label;
     if (typeof project !== "string" || typeof skill !== "string" || typeof server !== "string" || !entry.names.every((name) => typeof name === "string" && namePattern.test(name)))
@@ -157204,12 +157150,12 @@ async function read(path = resolveGrantsStorePath()) {
 function canonical(value) {
   if (Array.isArray(value))
     return `[${value.map(canonical).join(",")}]`;
-  if (record16(value))
+  if (record15(value))
     return `{${Object.keys(value).filter((key) => value[key] !== undefined).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
   return JSON.stringify(value) ?? "null";
 }
 function declarationDigest(identity) {
-  return createHash7("sha256").update(canonical(identity)).digest("hex");
+  return createHash8("sha256").update(canonical(identity)).digest("hex");
 }
 
 class GrantsLockLostError extends Error {
@@ -157253,7 +157199,7 @@ async function update(path, mutate) {
         await rename4(temporary, path);
         break;
       } catch (error) {
-        if (process.platform !== "win32" || !record16(error) || !["EPERM", "EACCES", "EBUSY"].includes(String(error.code)) || attempt >= 5)
+        if (process.platform !== "win32" || !record15(error) || !["EPERM", "EACCES", "EBUSY"].includes(String(error.code)) || attempt >= 5)
           throw error;
         await delay7(50 * 2 ** attempt);
       }
@@ -157927,23 +157873,40 @@ class SkillMcpManager {
   }
   async listTools(info, context, options) {
     const client = await this.getOrCreateClientWithRetry(info, context.config, options);
-    const result = await client.listTools();
-    return result.tools;
+    return this.collectPages(async (cursor) => {
+      const result = await client.listTools(cursor === undefined ? undefined : { cursor });
+      return { items: result.tools, nextCursor: result.nextCursor };
+    });
   }
   async listResources(info, context, options) {
     const client = await this.getOrCreateClientWithRetry(info, context.config, options);
-    const result = await client.listResources();
-    return result.resources;
+    return this.collectPages(async (cursor) => {
+      const result = await client.listResources(cursor === undefined ? undefined : { cursor });
+      return { items: result.resources, nextCursor: result.nextCursor };
+    });
   }
   async listPrompts(info, context, options) {
     const client = await this.getOrCreateClientWithRetry(info, context.config, options);
-    const result = await client.listPrompts();
-    return result.prompts;
+    return this.collectPages(async (cursor) => {
+      const result = await client.listPrompts(cursor === undefined ? undefined : { cursor });
+      return { items: result.prompts, nextCursor: result.nextCursor };
+    });
+  }
+  async collectPages(request) {
+    const items = [];
+    let cursor;
+    for (let page = 0;page < 100; page++) {
+      const result = await request(cursor);
+      items.push(...result.items);
+      if (result.nextCursor === undefined)
+        return items;
+      cursor = result.nextCursor;
+    }
+    throw new Error("MCP list pagination exceeded 100 pages.");
   }
   async callTool(info, context, name, args, options) {
     return await this.withOperationRetry(info, context.config, options, async (client) => {
-      const result = await client.callTool({ name, arguments: args });
-      return result.content;
+      return await client.callTool({ name, arguments: args });
     });
   }
   async readResource(info, context, uri, options) {
@@ -158077,7 +158040,7 @@ import { mkdirSync as mkdirSync24, readFileSync as readFileSync68 } from "fs";
 import { dirname as dirname53 } from "path";
 
 // packages/omo-opencode/src/features/tui-sidebar/mirror-path.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import { realpathSync as realpathSync24 } from "fs";
 import { homedir as homedir29 } from "os";
 import { join as join137, resolve as resolve38 } from "path";
@@ -158095,12 +158058,12 @@ function canonicalProjectDir(projectDir) {
   }
 }
 function mirrorFilePath(projectDir) {
-  const projectHash = createHash8("sha1").update(canonicalProjectDir(projectDir)).digest("hex").slice(0, 16);
+  const projectHash = createHash9("sha1").update(canonicalProjectDir(projectDir)).digest("hex").slice(0, 16);
   return join137(mirrorStorageDir(), `${projectHash}.json`);
 }
 
 // packages/omo-opencode/src/features/tui-sidebar/snapshot-schema.ts
-import { z as z63 } from "zod";
+import { z as z62 } from "zod";
 var AGENT_STATUS_VALUES = [
   "busy",
   "idle",
@@ -158116,32 +158079,32 @@ var BACKGROUND_TASK_STATUS_VALUES = [
   "cancelled",
   "interrupt"
 ];
-var AgentRowSchema = z63.object({
-  name: z63.string(),
-  status: z63.enum(AGENT_STATUS_VALUES)
+var AgentRowSchema = z62.object({
+  name: z62.string(),
+  status: z62.enum(AGENT_STATUS_VALUES)
 });
-var JobRowSchema = z63.object({
-  title: z63.string(),
-  status: z63.enum(BACKGROUND_TASK_STATUS_VALUES),
-  toolCalls: z63.number().int().nonnegative().nullable(),
-  lastTool: z63.string().nullable()
+var JobRowSchema = z62.object({
+  title: z62.string(),
+  status: z62.enum(BACKGROUND_TASK_STATUS_VALUES),
+  toolCalls: z62.number().int().nonnegative().nullable(),
+  lastTool: z62.string().nullable()
 });
-var LoopLiveSchema = z63.object({
-  kind: z63.literal("live"),
-  goalsDone: z63.number().int().nonnegative(),
-  goalsTotal: z63.number().int().nonnegative(),
-  pass: z63.number().int().nonnegative(),
-  fail: z63.number().int().nonnegative(),
-  pending: z63.number().int().nonnegative(),
-  blocked: z63.number().int().nonnegative(),
-  activeGoal: z63.string().nullable()
+var LoopLiveSchema = z62.object({
+  kind: z62.literal("live"),
+  goalsDone: z62.number().int().nonnegative(),
+  goalsTotal: z62.number().int().nonnegative(),
+  pass: z62.number().int().nonnegative(),
+  fail: z62.number().int().nonnegative(),
+  pending: z62.number().int().nonnegative(),
+  blocked: z62.number().int().nonnegative(),
+  activeGoal: z62.string().nullable()
 });
-var TuiRuntimeSnapshotSchema = z63.object({
-  version: z63.literal(MIRROR_SCHEMA_VERSION),
-  projectDir: z63.string(),
-  updatedAt: z63.number(),
-  activeAgents: z63.array(AgentRowSchema),
-  jobBoard: z63.array(JobRowSchema),
+var TuiRuntimeSnapshotSchema = z62.object({
+  version: z62.literal(MIRROR_SCHEMA_VERSION),
+  projectDir: z62.string(),
+  updatedAt: z62.number(),
+  activeAgents: z62.array(AgentRowSchema),
+  jobBoard: z62.array(JobRowSchema),
   loop: LoopLiveSchema.nullable()
 });
 
@@ -158156,25 +158119,25 @@ function writeMirror(projectDir, snapshot) {
 // packages/omo-opencode/src/features/tui-sidebar/loop-reader.ts
 import { readdirSync as readdirSync32, readFileSync as readFileSync69, statSync as statSync16 } from "fs";
 import { join as join138 } from "path";
-import { z as z64 } from "zod";
-var CriterionSchema = z64.object({
-  status: z64.string()
+import { z as z63 } from "zod";
+var CriterionSchema = z63.object({
+  status: z63.string()
 });
-var GoalBaseSchema = z64.object({
-  id: z64.string(),
-  title: z64.string(),
-  status: z64.string()
+var GoalBaseSchema = z63.object({
+  id: z63.string(),
+  title: z63.string(),
+  status: z63.string()
 });
-var CurrentLoopSchema = z64.object({
-  version: z64.literal(1),
-  activeGoalId: z64.string().optional(),
-  goals: z64.array(GoalBaseSchema.extend({
-    successCriteria: z64.array(CriterionSchema)
+var CurrentLoopSchema = z63.object({
+  version: z63.literal(1),
+  activeGoalId: z63.string().optional(),
+  goals: z63.array(GoalBaseSchema.extend({
+    successCriteria: z63.array(CriterionSchema)
   }))
 });
-var LegacyLoopSchema = z64.object({
-  goals: z64.array(GoalBaseSchema.extend({
-    criteria: z64.array(CriterionSchema)
+var LegacyLoopSchema = z63.object({
+  goals: z63.array(GoalBaseSchema.extend({
+    criteria: z63.array(CriterionSchema)
   }))
 });
 function readActiveLoop(projectDir) {
@@ -174865,7 +174828,7 @@ var grep_app = {
 import { existsSync as existsSync111, readFileSync as readFileSync76 } from "fs";
 import { delimiter as delimiter2, dirname as dirname56, resolve as resolve41 } from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
-import { z as z65 } from "zod";
+import { z as z64 } from "zod";
 
 // packages/omo-opencode/src/mcp/cli-suffix.ts
 function normalizeCliPath(path) {
@@ -174966,8 +174929,8 @@ var PROJECT_LSP_CONFIGS = [".opencode/lsp.json", ".omo/lsp.json", ".omo/lsp-clie
 var DAEMON_PACKAGE_NAME = "@code-yeongyu/lsp-daemon";
 var OMO_LSP_DAEMON_CLI = "OMO_LSP_DAEMON_CLI";
 var OMO_LSP_DAEMON_VERSION = "OMO_LSP_DAEMON_VERSION";
-var DaemonPackageSchema = z65.object({
-  version: z65.string().min(1)
+var DaemonPackageSchema = z64.object({
+  version: z64.string().min(1)
 });
 var LSP_BOOTSTRAP_SCRIPT = [
   "const { existsSync } = require('node:fs')",
@@ -175811,14 +175774,14 @@ function createTeamModeToolsRecord(args) {
 // node_modules/.bun/@opencode-ai+sdk@1.18.31/node_modules/@opencode-ai/sdk/dist/v2/server.js
 var import_cross_spawn3 = __toESM(require_cross_spawn(), 1);
 // packages/omo-opencode/src/plugin/native-skills.ts
-import { z as z66 } from "zod";
-var NativeSkillEntrySchema = z66.object({
-  name: z66.string(),
-  description: z66.string().default(""),
-  location: z66.string(),
-  content: z66.string()
+import { z as z65 } from "zod";
+var NativeSkillEntrySchema = z65.object({
+  name: z65.string(),
+  description: z65.string().default(""),
+  location: z65.string(),
+  content: z65.string()
 });
-var NativeSkillEntriesSchema = z66.array(NativeSkillEntrySchema);
+var NativeSkillEntriesSchema = z65.array(NativeSkillEntrySchema);
 function getObjectProperty(value, property) {
   if (typeof value !== "object" || value === null)
     return;
@@ -176969,7 +176932,7 @@ async function resolveParticipant2(teamRunId, sessionID, config, deps) {
 }
 
 // packages/omo-opencode/src/features/team-mode/tools/lifecycle-inline-spec.ts
-import { z as z67 } from "zod";
+import { z as z66 } from "zod";
 init_types2();
 var TEAM_CREATE_USAGE = 'team_create requires exactly one of teamName or inline_spec. Use team_create({ teamName: "existing-team" }) or team_create({ inline_spec: { name: "team-name", members: [{ name: "worker", category: "quick", prompt: "Do the assigned work." }] } }).';
 function omitEmptyStringArgs(rawArgs) {
@@ -176978,10 +176941,10 @@ function omitEmptyStringArgs(rawArgs) {
   }
   return Object.fromEntries(Object.entries(rawArgs).filter(([, value]) => value !== ""));
 }
-var TeamCreateArgsSchema = z67.preprocess(omitEmptyStringArgs, z67.object({
-  teamName: z67.string().min(1).nullish(),
-  inline_spec: z67.unknown().nullish(),
-  leadSessionId: z67.string().nullish()
+var TeamCreateArgsSchema = z66.preprocess(omitEmptyStringArgs, z66.object({
+  teamName: z66.string().min(1).nullish(),
+  inline_spec: z66.unknown().nullish(),
+  leadSessionId: z66.string().nullish()
 }).superRefine((value, ctx) => {
   const optionCount = Number(value.teamName != null) + Number(value.inline_spec != null);
   if (optionCount !== 1) {
@@ -177103,7 +177066,7 @@ function createTeamCreateTool(config, client, bgMgr, tmuxMgr, executorConfig, de
   });
 }
 // packages/omo-opencode/src/features/team-mode/tools/lifecycle-shutdown-tools.ts
-import { z as z68 } from "zod";
+import { z as z67 } from "zod";
 // packages/omo-opencode/src/features/team-mode/team-runtime/shutdown.ts
 init_store2();
 init_shutdown_helpers();
@@ -177192,13 +177155,13 @@ async function rejectShutdown(teamRunId, memberName, rejectorName, reason, confi
 
 // packages/omo-opencode/src/features/team-mode/tools/lifecycle-shutdown-tools.ts
 init_store();
-var TeamDeleteArgsSchema = z68.object({ teamRunId: z68.string().min(1), force: z68.boolean().optional() });
-var TeamShutdownRequestArgsSchema = z68.object({ teamRunId: z68.string().min(1), targetMemberName: z68.string().min(1) });
-var TeamApproveShutdownArgsSchema = z68.object({ teamRunId: z68.string().min(1), memberName: z68.string().min(1) });
-var TeamRejectShutdownArgsSchema = z68.object({
-  teamRunId: z68.string().min(1),
-  memberName: z68.string().min(1),
-  reason: z68.string().min(1)
+var TeamDeleteArgsSchema = z67.object({ teamRunId: z67.string().min(1), force: z67.boolean().optional() });
+var TeamShutdownRequestArgsSchema = z67.object({ teamRunId: z67.string().min(1), targetMemberName: z67.string().min(1) });
+var TeamApproveShutdownArgsSchema = z67.object({ teamRunId: z67.string().min(1), memberName: z67.string().min(1) });
+var TeamRejectShutdownArgsSchema = z67.object({
+  teamRunId: z67.string().min(1),
+  memberName: z67.string().min(1),
+  reason: z67.string().min(1)
 });
 var defaultTeamShutdownToolDeps = {
   listActiveTeams,
@@ -181075,7 +181038,7 @@ function parseWindowsProcessTable(output) {
   const entries = Array.isArray(parsed) ? parsed : parsed === undefined ? [] : [parsed];
   const processes = [];
   for (const entry of entries) {
-    if (!isRecord14(entry))
+    if (!isRecord13(entry))
       continue;
     const pid = numberField(entry, "ProcessId");
     const ppid = numberField(entry, "ParentProcessId");
@@ -181109,7 +181072,7 @@ function stringField(record, key) {
   const value = record[key];
   return typeof value === "string" ? value : undefined;
 }
-function isRecord14(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -181213,7 +181176,7 @@ async function attestLspDaemonOwner(target, deps = {}) {
   }
 }
 function parseLspDaemonOwner(value) {
-  if (!isRecord15(value))
+  if (!isRecord14(value))
     return null;
   const pid = value["pid"];
   const nonce = value["nonce"];
@@ -181225,7 +181188,7 @@ function parseLspDaemonOwner(value) {
     return null;
   if (typeof startedAt !== "string" || startedAt.length === 0)
     return null;
-  if (!isRecord15(endpoint))
+  if (!isRecord14(endpoint))
     return null;
   const kind = endpoint["kind"];
   const path = endpoint["path"];
@@ -181277,7 +181240,7 @@ async function pingLspDaemonOwner(endpoint, authToken) {
         return finish(null);
       try {
         const response = JSON.parse(line);
-        if (!isRecord15(response) || response["id"] !== OWNER_PING_REQUEST_ID || "error" in response) {
+        if (!isRecord14(response) || response["id"] !== OWNER_PING_REQUEST_ID || "error" in response) {
           return finish(null);
         }
         finish(parseLspDaemonOwner(response["result"]));
@@ -181290,7 +181253,7 @@ async function pingLspDaemonOwner(endpoint, authToken) {
 function sameOwner(left, right) {
   return left.pid === right.pid && left.nonce === right.nonce && left.startedAt === right.startedAt && left.endpoint.kind === right.endpoint.kind && left.endpoint.path === right.endpoint.path && left.endpoint.dev === right.endpoint.dev && left.endpoint.ino === right.endpoint.ino;
 }
-function isRecord15(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -181865,13 +181828,13 @@ function getTelemetryHost(env = process.env, defaultHost = DEFAULT_POSTHOG_HOST)
 }
 
 // packages/telemetry-core/src/machine-id.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import os6 from "os";
 function getDefaultTelemetryOsProvider() {
   return os6;
 }
 function getTelemetryDistinctId(machineIdPrefix, osProvider = getDefaultTelemetryOsProvider()) {
-  return createHash9("sha256").update(`${machineIdPrefix}${osProvider.hostname()}`).digest("hex");
+  return createHash10("sha256").update(`${machineIdPrefix}${osProvider.hostname()}`).digest("hex");
 }
 
 // packages/telemetry-core/src/injected-client.ts
@@ -189218,7 +189181,7 @@ var TOPLEVEL_SENTINELS = [
     field: "window_id"
   }
 ];
-function isRecord16(value) {
+function isRecord15(value) {
   return typeof value == "object" && value !== null && !Array.isArray(value);
 }
 function toRfc3339(timestamp) {
@@ -189240,7 +189203,7 @@ function relocateInto(properties, key, value) {
     properties[key] = value;
 }
 function buildV1Event(message) {
-  const sourceProperties = isRecord16(message.properties) ? message.properties : {};
+  const sourceProperties = isRecord15(message.properties) ? message.properties : {};
   const properties = {
     ...sourceProperties
   };