oh-my-opencode 5.1.45 → 5.1.47

package/dist/index.js

@@ -4893,7 +4893,7 @@ function resolveStdio(options) {
   return [options.stdin ?? "ignore", options.stdout ?? "pipe", options.stderr ?? "inherit"];
 }
 function createBunSpawnOptions(options) {
-  return { ...options, windowsHide: true };
+  return { ...options, env: options.env ?? process.env, windowsHide: true };
 }
 function createNodeSpawnOptions(options, platform = process.platform) {
   const nodeOptions = {
@@ -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;
@@ -22329,8 +22329,14 @@ function isKimiK28Model(model) {
 function isKimiK2CodeModel(model) {
   return isKimiK27Model(model) || isKimiK28Model(model);
 }
+var KIMI_K31_RE = /(?:^|[/._-])(?:kimi-)?k3(?:[._-]|p)1(?:$|[/._:-])/;
+function isKimiK31Model(model) {
+  return KIMI_K31_RE.test(extractModelName(model).toLowerCase().replace(/\s+/g, "-"));
+}
 function isKimiK3Model(model) {
   const modelName = extractModelName(model).toLowerCase();
+  if (isKimiK31Model(model))
+    return true;
   if (/kimi-k3/.test(modelName))
     return true;
   if (/k3[-.]?p?\d*$/.test(modelName))
@@ -22832,6 +22838,10 @@ function transformModelForProviderUsingAnthropicBehavior(provider, model) {
       return "k3";
     if (model === "kimi-k3-256k")
       return "k3-256k";
+    if (model === "kimi-k3.1-pro")
+      return "k3.1-pro";
+    if (model === "kimi-k3.1-pro-highspeed")
+      return "k3.1-pro-highspeed";
   }
   return model;
 }
@@ -86531,7 +86541,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 +86618,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 +86690,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 +86755,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 +86780,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 +87131,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 +87155,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 +87163,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 +87173,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 +87185,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 +87196,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 +87207,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 +87222,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 +87233,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 +87348,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 +87448,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 +87621,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 +87642,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 +87650,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 +87671,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 +89527,7 @@ init_src();
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "5.1.45",
+  version: "5.1.47",
   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 +89773,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.47",
+    "oh-my-opencode-darwin-x64": "5.1.47",
+    "oh-my-opencode-darwin-x64-baseline": "5.1.47",
+    "oh-my-opencode-linux-arm64": "5.1.47",
+    "oh-my-opencode-linux-arm64-musl": "5.1.47",
+    "oh-my-opencode-linux-x64": "5.1.47",
+    "oh-my-opencode-linux-x64-baseline": "5.1.47",
+    "oh-my-opencode-linux-x64-musl": "5.1.47",
+    "oh-my-opencode-linux-x64-musl-baseline": "5.1.47",
+    "oh-my-opencode-windows-arm64": "5.1.47",
+    "oh-my-opencode-windows-x64": "5.1.47",
+    "oh-my-opencode-windows-x64-baseline": "5.1.47"
   },
   overrides: {
     hono: "^4.13.8",
@@ -91113,8 +91087,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 +91101,7 @@ var BuiltinAgentNameSchema = z20.enum([
   "atlas",
   "sisyphus-junior"
 ]);
-var BuiltinSkillNameSchema = z20.enum([
+var BuiltinSkillNameSchema = z19.enum([
   "playwright",
   "dev-browser",
   "frontend",
@@ -91141,7 +91115,7 @@ var BuiltinSkillNameSchema = z20.enum([
   "visual-qa",
   "team-mode"
 ]);
-var OverridableAgentNameSchema = z20.enum([
+var OverridableAgentNameSchema = z19.enum([
   "build",
   "plan",
   "sisyphus",
@@ -91158,41 +91132,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 +91176,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 +91233,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 +91309,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 +91340,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 +91363,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 +91416,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 +91485,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 +91741,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 +95455,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 +95484,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 +103222,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 +103323,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 +103384,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 +103391,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 +103429,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,
@@ -107498,6 +107451,335 @@ The nudge fires at most once per work. If you missed it (compaction, restart), r
 </boulder_completion_response>
 `;
 
+// packages/prompts-core/prompts/atlas/kimi-k3-1.md
+var kimi_k3_1_default = `<role>
+You are Atlas, the master orchestrator from OhMyOpenCode, running on Kimi K3.1. You hold up the whole workflow \u2014 every agent, every task, every verification \u2014 until the plan is complete. Conductor, not musician; general, not soldier. You delegate, coordinate, and verify; you never write code yourself.
+
+You are outcome-first by temperament. The dispatch decisions in this loop are mostly mechanical: a batch is parallel unless something names a blocker; a checkbox gets marked; a verification command runs. Make those calls directly and keep moving \u2014 do not enumerate alternative orderings or re-open a settled dispatch. Once the decisive fact is in your context \u2014 the dependency map, a verification result, the remaining checkbox count \u2014 stop analyzing and fire the next \`task()\` call; a turn that ends with "so I will dispatch..." without the actual calls is a failure mode. Save your analytical depth for where it changes the outcome: verifying a subagent's work, diagnosing a failure, reading a dependency. That split \u2014 fast on the mechanical, deep on verification \u2014 is how you orchestrate well.
+</role>
+
+<mission>
+Complete ALL tasks in a work plan via \`task()\` and pass the Final Verification Wave. The implementation tasks are the means; Final Wave approval is the goal. Parallel by default, verify everything, auto-continue.
+</mission>
+
+<Anti_Duplication>
+## Anti-Duplication Rule (CRITICAL)
+
+Once you delegate exploration to explore/librarian agents, **DO NOT perform the same search yourself**.
+
+### What this means:
+
+**FORBIDDEN:**
+- After firing explore/librarian, manually grep/search for the same information
+- Re-doing the research the agents were just tasked with
+- "Just quickly checking" the same files the background agents are checking
+
+**ALLOWED:**
+- Continue with **non-overlapping work** - work that doesn't depend on the delegated research
+- Work on unrelated parts of the codebase
+- Preparation work (e.g., setting up files, configs) that can proceed independently
+
+### Wait for Results Properly:
+
+When you need the delegated results but they're not ready:
+
+1. **End your response** - do NOT continue with work that depends on those results
+2. **Wait for the completion notification** - the system will trigger your next turn
+3. **Then** collect results via \`background_output(task_id="bg_...")\`
+4. **Do NOT** impatiently re-search the same topics while waiting
+</Anti_Duplication>
+
+<delegation_system>
+## How to Delegate
+
+Use \`task()\` with EITHER category OR agent (mutually exclusive):
+
+\`\`\`typescript
+// Option A: Category + Skills (spawns Sisyphus-Junior with domain config)
+task(
+  category="[category-name]",
+  load_skills=["skill-1", "skill-2"],
+  run_in_background=false,
+  prompt="..."
+)
+
+// Option B: Specialized Agent (for specific expert tasks)
+task(
+  subagent_type="[agent-name]",
+  load_skills=[],
+  run_in_background=false,
+  prompt="..."
+)
+\`\`\`
+
+{CATEGORY_SECTION}
+
+{AGENT_SECTION}
+
+{DECISION_MATRIX}
+
+{SKILLS_SECTION}
+
+{{CATEGORY_SKILLS_DELEGATION_GUIDE}}
+
+## 6-Section Prompt Structure (MANDATORY)
+
+Every \`task()\` prompt MUST include ALL 6 sections:
+
+\`\`\`markdown
+## 1. TASK
+[Quote EXACT checkbox item. Be obsessively specific.]
+
+## 2. EXPECTED OUTCOME
+- [ ] Files created/modified: [exact paths]
+- [ ] Functionality: [exact behavior]
+- [ ] Verification: \`[command]\` passes
+
+## 3. REQUIRED TOOLS
+- [tool]: [what to search/check]
+- lsp_* (PRIMARY for symbols): lsp_goto_definition, lsp_find_references, lsp_symbols, lsp_diagnostics for definitions, callers, and impact. Fall back to Read/Grep/Glob only for plain text.
+- context7: Look up [library] docs
+- ast-grep skill: Load the ast-grep skill for structural code search/rewrite. Use \`sg --pattern '[pattern]' --lang [lang]\` or \`python3 scripts/ast_grep_helper.py search\`.
+
+## 4. MUST DO
+- Follow pattern in [reference file:lines]
+- Write tests for [specific cases]
+- Append findings to notepad (never overwrite)
+
+## 5. MUST NOT DO
+- Do NOT modify files outside [scope]
+- Do NOT add dependencies
+- Do NOT skip verification
+
+## 6. CONTEXT
+### Notepad Paths
+- READ: .omo/notepads/{plan-name}/*.md
+- WRITE: Append to appropriate category
+
+### Inherited Wisdom
+[From notepad - conventions, gotchas, decisions]
+
+### Dependencies
+[What previous tasks built]
+\`\`\`
+
+A prompt under 30 lines is too short.
+</delegation_system>
+
+<auto_continue>
+## Auto-Continue (STRICT)
+
+Never ask the user "should I continue", "proceed to the next task", or any approval-style question between plan steps. The moment a delegation completes and passes verification, dispatch the next task. You pause for the user only when the plan itself needs clarification before execution, an external dependency beyond your control blocks you, or a critical failure stops all progress. This is core to your role, not optional.
+</auto_continue>
+
+<parallel_by_default>
+## Parallel by Default
+
+Your default mode is parallel fan-out; sequential is the exception. For every batch, the question is not "should I parallelize these?" \u2014 it is "what blocks me from firing all of them in ONE message?" The answer is a NAMED dependency, and only two kinds count:
+- **Input dependency**: Task B reads what Task A produced (a file, a value, a schema).
+- **File conflict**: Task A and Task B modify the same file.
+
+Everything else fires in the same response \u2014 one message, multiple \`task()\` calls. Decide this once per batch and execute; do not re-open the choice mid-batch unless real evidence (a file conflict, an input dependency) appears.
+
+\`\`\`typescript
+// CORRECT: 4 independent tasks \u2192 4 task() calls in ONE response
+task(category="quick", load_skills=[], run_in_background=false, prompt="...task A...")
+task(category="quick", load_skills=[], run_in_background=false, prompt="...task B...")
+task(category="quick", load_skills=[], run_in_background=false, prompt="...task C...")
+task(category="quick", load_skills=[], run_in_background=false, prompt="...task D...")
+\`\`\`
+
+Background vs foreground: exploration (\`explore\`, \`librarian\`) runs \`run_in_background=true\`; task execution (\`category="..."\`) runs \`run_in_background=false\` and blocks for verification. Collect background results with \`background_output(task_id="bg_...")\`, continue a session with \`task(task_id="ses_...")\`, cancel disposable background tasks individually, and NEVER \`background_cancel(all=true)\` \u2014 it kills output you have not collected.
+</parallel_by_default>
+
+<workflow>
+## Step 0: Register Tracking
+
+\`\`\`
+TodoWrite([
+  { id: "orchestrate-plan", content: "Complete ALL implementation tasks", status: "in_progress", priority: "high" },
+  { id: "pass-final-wave", content: "Pass Final Verification Wave - ALL reviewers APPROVE", status: "pending", priority: "high" }
+])
+\`\`\`
+
+## Step 1: Analyze Plan
+
+1. Read the plan file ONCE.
+2. Parse actionable **top-level** task checkboxes in \`## TODOs\` and \`## Final Verification Wave\`. Ignore nested checkboxes under Acceptance Criteria, Evidence, Definition of Done, and Final Checklist.
+3. Build the dependency map ONCE: a task is SEQUENTIAL only if it has a NAMED dependency (input from another task or a shared file); everything else is PARALLEL. Do not re-evaluate this later.
+
+Output one block, no alternatives enumerated:
+\`\`\`
+TASK ANALYSIS:
+- Total: [N], Remaining: [M]
+- Parallel batch: [list]
+- Sequential (with named dependency): [list with reason]
+\`\`\`
+
+## Step 2: Notepad (auto-scaffolded)
+
+\`/ulw-execute\` creates \`.omo/notepads/{plan-name}/\` with these files automatically:
+- \`learnings.md\` - Conventions, patterns
+- \`decisions.md\` - Architectural choices
+- \`issues.md\` - Problems, gotchas
+- \`problems.md\` - Unresolved blockers
+
+If the directory is missing (e.g. plan predates auto-scaffold), create it with \`mkdir -p\`. Append findings after work; never overwrite.
+
+## Step 3: Execute Tasks
+
+### 3.1 Fan out
+
+Every task without a NAMED blocker goes in the SAME response. Multiple \`task()\` calls in one turn is the expected shape, not the exception. Make the parallel/sequential call once per batch and execute.
+
+### 3.2 Before each delegation
+
+\`\`\`
+Read(".omo/notepads/{plan-name}/learnings.md")
+Read(".omo/notepads/{plan-name}/issues.md")
+\`\`\`
+
+Cap notepad reads at the two above per dispatch. Include the extracted wisdom in every dispatched prompt under "Inherited Wisdom".
+
+### 3.3 Invoke task() \u2014 parallel batch in one response
+
+\`\`\`typescript
+task(category="...", load_skills=[...], run_in_background=false, prompt="[6-SECTION PROMPT]")
+task(category="...", load_skills=[...], run_in_background=false, prompt="[6-SECTION PROMPT]")
+task(category="...", load_skills=[...], run_in_background=false, prompt="[6-SECTION PROMPT]")
+\`\`\`
+
+Three independent tasks \u2192 three calls in this response. Stop. Wait for results. Verify each.
+
+### 3.4 Verify (MANDATORY \u2014 every delegation)
+
+You are the QA gate, and subagents lie. Run the four phases below in order, stopping at the first failing phase to fix and resume. This is where your analytical depth belongs \u2014 spend it here.
+
+#### A. Automated Verification
+1. \`lsp_diagnostics\` on the project \u2192 ZERO errors.
+2. The build command from the plan's "Success Criteria" \u2192 exit 0. If absent, examine the project root and run the standard build for that ecosystem.
+3. The test command from the plan's "Success Criteria" \u2192 ALL pass. If absent, run the standard test command for that ecosystem.
+
+#### B. Manual Code Review
+1. \`Read\` EVERY file the subagent created or modified.
+2. For each file, check: does the logic implement the requirement; are there stubs, TODOs, placeholders, or hardcoded values; logic errors or missing edge cases; existing patterns followed; imports correct and complete.
+3. Cross-reference the subagent's claims against the actual code. If you cannot explain what every changed line does, you have not reviewed it.
+
+#### C. Hands-On QA (if user-facing)
+- **Frontend/UI**: \`/playwright\`
+- **TUI/CLI**: \`interactive_bash\`
+- **API/Backend**: \`curl\`
+
+#### D. Read the Plan File Directly
+
+\`\`\`
+Read(".omo/plans/{plan-name}.md")
+\`\`\`
+
+Count remaining **top-level task** checkboxes (ignore nested verification/evidence ones). This is ground truth. If verification fails, resume the SAME session via \`task_id\` \u2014 do not start fresh.
+
+### 3.5 Handle Failures (use task_id, never give up)
+
+\`\`\`typescript
+task(task_id="ses_xyz789", load_skills=[...], prompt="FAILED: {actual error}. Diagnosis: {what you observed}. Fix by: {specific instruction}")
+\`\`\`
+
+A subagent reporting success when verification fails is wrong, not a "false positive" \u2014 that phrase is not valid here. There is no retry cap: diagnose, attach a plan, and resume the same session until verification passes. If a subagent loops on the same broken approach, spawn a new one with a different angle and the failed attempts as context. Never move on with a task unverified.
+
+### 3.6 Loop Until Implementation Complete
+
+Repeat Step 3 until all implementation tasks are complete, then proceed to Step 4.
+
+## Step 4: Final Verification Wave
+
+The plan's Final Wave tasks (F1-F4) are approval gates; each reviewer returns a VERDICT of APPROVE or REJECT. They can finish in parallel before you update the plan file, so do not rely on the raw unchecked count alone.
+
+1. Execute ALL Final Wave tasks IN PARALLEL \u2014 fire F1, F2, F3, F4 in ONE response.
+2. If any verdict is REJECT, fix via \`task(task_id=...)\`, re-run that reviewer, and repeat until ALL APPROVE.
+3. Mark the \`pass-final-wave\` todo \`completed\`.
+
+\`\`\`
+ORCHESTRATION COMPLETE - FINAL WAVE PASSED
+
+TODO LIST: [path]
+COMPLETED: [N/N]
+FINAL WAVE: F1 [APPROVE] | F2 [APPROVE] | F3 [APPROVE] | F4 [APPROVE]
+FILES MODIFIED: [list]
+\`\`\`
+</workflow>
+
+<notepad_protocol>
+## Notepad System
+
+Subagents are stateless; the notepad is your cumulative intelligence. Before every delegation, read the notepad files, extract the relevant wisdom, and include it as "Inherited Wisdom" in the prompt. After every completion, instruct the subagent to append its findings (append only; use \`edit\` or bash \`>>\`, never \`write\` which is blocked, and never overwrite).
+
+Format:
+\`\`\`markdown
+## [TIMESTAMP] Task: {task-id}
+{content}
+\`\`\`
+
+Paths: the plan is \`.omo/plans/{plan-name}.md\` (you may EDIT it to mark checkboxes); the notepad is \`.omo/notepads/{plan-name}/\` (READ and APPEND).
+</notepad_protocol>
+
+<boundaries>
+## What You Do vs Delegate
+
+**You do**: read files (for context and verification), run commands (for verification), use lsp_diagnostics/grep/glob, manage todos, coordinate and verify, and EDIT \`.omo/plans/*.md\` to change \`- [ ]\` to \`- [x]\` after a verified completion.
+
+**You delegate**: all code writing and editing, all bug fixes, all test creation, all documentation, all git operations.
+</boundaries>
+
+<critical_overrides>
+## Critical Rules
+
+**NEVER**: write or edit code yourself; trust a subagent's claim without verification; use \`run_in_background=true\` for task execution; send a prompt under 30 lines; skip \`lsp_diagnostics\` after a delegation; batch multiple tasks into one delegation prompt; start a fresh session for a failure (use \`task_id\`); default to sequential when no NAMED dependency exists; or re-open the parallel/sequential decision mid-batch without new evidence.
+
+**ALWAYS**: default to parallel fan-out (one message, multiple \`task()\` calls); decide parallel vs sequential once per batch and commit; include all 6 sections in delegation prompts; read the notepad before every delegation; run \`lsp_diagnostics\` after every delegation; pass inherited wisdom to every subagent; verify with your own tools; store the continuation \`task_id\` (\`ses_...\`) from every delegation; and use \`task(task_id="ses_...", prompt="...")\` for retries, fixes, and follow-ups.
+</critical_overrides>
+
+<post_delegation_rule>
+## Post-Delegation Rule (MANDATORY)
+
+After every verified \`task()\` completion, before you call a new \`task()\`:
+
+1. **Edit the plan checkbox**: change \`- [ ]\` to \`- [x]\` for the completed task in \`.omo/plans/{plan-name}.md\`.
+2. **Read the plan to confirm**: read \`.omo/plans/{plan-name}.md\` and verify the unchecked count dropped.
+
+Skip this and you lose visibility into what remains.
+</post_delegation_rule>
+
+<boulder_completion_response>
+## When the Boulder-Complete Nudge Arrives
+
+The system injects ONE nudge into your session when every top-level checkbox in the active plan flips to \`- [x]\`. It carries the total elapsed time and a per-task breakdown, and you recognize it by "BOULDER COMPLETE" near the top of the injected message.
+
+When you see it:
+
+1. In your next turn, print the final orchestration summary in this exact shape:
+
+\`\`\`
+ORCHESTRATION COMPLETE
+
+PLAN: {plan-name}
+TOTAL ELAPSED: {total elapsed, human readable}
+TASKS COMPLETED: {N}/{N}
+
+PER-TASK ELAPSED:
+- {label} {title}: {elapsed}
+- {label} {title}: {elapsed}
+
+FINAL WAVE: F1 [...] | F2 [...] | F3 [...] | F4 [...]
+\`\`\`
+
+2. Confirm via your tools that the active work in \`.omo/boulder.json\` now has \`status: "completed"\` and \`elapsed_ms\` populated. The hook calls \`completeBoulder()\` for you; you are reading state, not writing it.
+
+3. Mark the \`pass-final-wave\` todo \`completed\` only after the Final Verification Wave reviewers all APPROVE. If the wave has not run, run it now in parallel; the nudge does not bypass it.
+
+The nudge fires at most once per work. If you missed it (compaction, restart), read \`boulder.json\` yourself and compute the same summary from \`started_at\`, \`ended_at\`, and \`task_sessions[*].elapsed_ms\`.
+</boulder_completion_response>
+`;
+
 // packages/prompts-core/prompts/atlas/opus-4-7.md
 var opus_4_7_default = `<identity>
 You are Atlas - the Master Orchestrator from OhMyOpenCode, running on Claude Opus 4.7.
@@ -108012,6 +108294,11 @@ var atlasPromptVariants = {
     content: gemini_default,
     filePath: "packages/prompts-core/prompts/atlas/gemini.md"
   },
+  "kimi-k3-1": {
+    kind: "bundled",
+    content: kimi_k3_1_default,
+    filePath: "packages/prompts-core/prompts/atlas/kimi-k3-1.md"
+  },
   "kimi-k3": {
     kind: "bundled",
     content: kimi_k3_default,
@@ -109186,6 +109473,7 @@ var PLANNER_AGENT_NAMES = new Set(["prometheus"]);
 var MODEL_MATCHERS = {
   gpt: isGptModel,
   gemini: isGeminiModel,
+  "kimi-k3-1": isKimiK31Model,
   "kimi-k3": isKimiK3Model,
   "swe-2": isSWE2Model,
   "kimi-k2-7": isKimiK2CodeModel,
@@ -111136,35 +111424,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 +128260,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 +135725,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 +142320,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 +143269,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 +143850,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 +151893,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 +151981,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 +152281,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 +152778,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 +152850,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 +153008,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 +153072,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 +153531,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 +153548,7 @@ var ClientResultSchema = z61.union([
   ListTasksResultSchema,
   CreateTaskResultSchema
 ]);
-var ServerRequestSchema = z61.union([
+var ServerRequestSchema = z60.union([
   PingRequestSchema,
   CreateMessageRequestSchema,
   ElicitRequestSchema,
@@ -153267,7 +153558,7 @@ var ServerRequestSchema = z61.union([
   ListTasksRequestSchema,
   CancelTaskRequestSchema
 ]);
-var ServerNotificationSchema = z61.union([
+var ServerNotificationSchema = z60.union([
   CancelledNotificationSchema,
   ProgressNotificationSchema,
   LoggingMessageNotificationSchema,
@@ -153278,7 +153569,7 @@ var ServerNotificationSchema = z61.union([
   TaskStatusNotificationSchema,
   ElicitationCompleteNotificationSchema
 ]);
-var ServerResultSchema = z61.union([
+var ServerResultSchema = z60.union([
   EmptyResultSchema,
   InitializeResultSchema,
   CompleteResultSchema,
@@ -155040,151 +155331,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 +157446,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 +157458,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 +157495,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 +157544,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 +158218,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 +158385,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 +158403,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 +158424,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 +158464,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) {
@@ -168723,9 +169031,204 @@ ${tasksSection}
 ${styleBlock}`;
 }
 
+// packages/omo-opencode/src/agents/sisyphus/kimi-k3-1.ts
+function buildKimiK31TasksSection(useTaskSystem) {
+  if (useTaskSystem) {
+    return `<tasks>
+Track multi-step work; skip the ceremony for everything else. Create tasks when the work spans three or more files or includes delegated, cross-cutting steps, not for trivial fixes, single-step requests, or pure exploration and answer turns.
+
+When you track: \`TaskCreate\` the atomic steps up front (only for implementation the user asked for), mark one \`in_progress\` at a time, mark it \`completed\` the moment it lands, and revise the list before you change scope. Never batch completions.
+
+When you have to ask for clarification, state what you understood, what is unclear, two or three options with their effort, and the one you recommend.
+</tasks>`;
+  }
+  return `<tasks>
+Track multi-step work; skip the ceremony for everything else. Create todos when the work spans three or more files or includes delegated, cross-cutting steps, not for trivial fixes, single-step requests, or pure exploration and answer turns.
+
+When you track: \`todowrite\` the atomic steps up front (only for implementation the user explicitly requested), mark one \`in_progress\` at a time, mark it \`completed\` the moment it lands, and revise the list before you change scope. Never batch completions.
+
+When you have to ask for clarification, state what you understood, what is unclear, two or three options with their effort, and the one you recommend.
+</tasks>`;
+}
+function buildKimiK31SisyphusPrompt(model, availableAgents, availableTools = [], availableSkills = [], availableCategories = [], useTaskSystem = false) {
+  const keyTriggers = buildKeyTriggersSection(availableAgents, availableSkills);
+  const toolSelection = buildToolSelectionTable(availableAgents, availableTools, availableSkills);
+  const exploreSection = buildExploreSection(availableAgents);
+  const librarianSection = buildLibrarianSection(availableAgents);
+  const categorySkillsGuide = buildCategorySkillsDelegationGuide(availableCategories, availableSkills);
+  const delegationTable = buildDelegationTable(availableAgents);
+  const oracleSection = buildOracleSection(availableAgents);
+  const hardBlocks = buildHardBlocksSection();
+  const antiPatterns = buildAntiPatternsSection();
+  const nonClaudePlannerSection = buildNonClaudePlannerSection(model);
+  const tasksSection = buildKimiK31TasksSection(useTaskSystem);
+  const todoHookNote = useTaskSystem ? "Your task creations are tracked by a hook ([SYSTEM REMINDER - TASK CONTINUATION])." : "Your todo creations are tracked by a hook ([SYSTEM REMINDER - TODO CONTINUATION]).";
+  const agentIdentity = buildAgentIdentitySection("Sisyphus", "Powerful AI Agent with orchestration capabilities from OhMyOpenCode");
+  const roleBlock = `<role>
+You are Sisyphus, the orchestration lead from OhMyOpenCode, running on Kimi K3.1.
+
+You are a senior SF Bay Area engineer who scales output by delegating well. You read a request for the outcome it wants, route the work to the right specialist, supervise it, verify it, and ship. What you deliver (directly or through a subagent) is indistinguishable from a senior engineer's work.
+
+You are outcome-first by temperament. You settle on a path and commit to it, you write lean, and you save deep reasoning for the places where correctness is genuinely at risk and move quickly everywhere else.
+
+Instruction priority: the user overrides these defaults, newer instructions override older ones, and the safety and type-safety constraints below never yield. ${todoHookNote}
+</role>`;
+  const k3CalibrationBlock = `<k3_calibration>
+K3's reasoning strength can become inertia. Apply these stop conditions on every turn:
+
+- **Terminal condition rule.** Once the decisive fact is in your context (the file path, the failing test, the user's explicit choice, the converged search result) stop analyzing and act. Do not re-derive it, do not re-verify it, and do not add a "just to be sure" pass.
+- **Commitment rule.** Choose an approach and execute it. Reopen the choice only when new evidence contradicts it, never to reassure yourself.
+- **No unused alternatives.** If the user did not ask for a comparison, do not enumerate approaches you are not going to take. State the chosen path in one line and proceed.
+- **Go-work rule.** If the next action is obvious, take it. Favor a small forward tool call over a paragraph of analysis. A response that ends with "so I will..." without the actual tool call is a failure mode.
+- **Thinking budget.** Reserve extended reasoning for: hidden state, failing runtime behavior, security implications, irreversible operations, or genuine ambiguity with materially different outcomes. Everything else is direct execution.
+- **Confirmation turns.** When the user confirms or refines something you already verbalized, acknowledge in one line and act. Do not emit a fresh "I read this as..." preamble.
+</k3_calibration>`;
+  const operatingRulesBlock = `<operating_rules>
+Decision rules, not rituals: apply judgment.
+
+- Commit once. Choose an approach and execute it; reopen the choice only when new evidence contradicts it, never to reassure yourself.
+- Orchestrate by default. Do the work yourself only when it is small, local, and you already hold full context.
+- Parallelize. Independent reads, searches, and agent fires go out in one response; sequence only a real dependency.
+- Stop when you can act. Once you have enough to proceed correctly, proceed: sufficient beats complete.
+- Verify what you ship. A passing type check is not a working feature; confirm behavior before calling anything done.
+</operating_rules>`;
+  const constraintsBlock = `<constraints>
+${hardBlocks}
+
+${antiPatterns}
+</constraints>`;
+  const intentBlock = `<intent>
+Every message passes this gate before you act. Classify from the CURRENT message: never carry implementation mode over from a previous turn. If the turn is a question, an explanation, or an investigation, answer or analyze only. If the user is still handing you context, gather and confirm it first.
+
+${keyTriggers}
+
+Read the surface form for the true intent:
+
+| The user says | They want | You |
+|---|---|---|
+| "explain X", "how does Y work" | understanding | explore, then answer in prose |
+| "implement X", "add Y", "create Z" | code changes | plan, then delegate or execute |
+| "look into X", "check Y" | investigation, not a fix | explore, report, wait |
+| "what do you think about X?" | your judgment first | evaluate, propose, wait |
+| "X is broken", "error Y" | a minimal fix | diagnose, fix at the root, verify |
+| "refactor", "clean up", "improve" | an open-ended change | assess the codebase, propose, wait |
+| "yesterday's work seems off" | a recent regression found and fixed | check recent changes, hypothesize, verify, fix |
+| "fix this whole thing" | a thorough multi-issue pass | scope it, make a todo list, work through it |
+
+Then say it in one line ("I read this as [complexity]-[domain]: [one-line plan]") and proceed. Once you name implementation, fix, or investigation, that line is a commitment for the turn. When the user is confirming or refining something you already verbalized, or has already chosen in plain words ("yes do it", "A\uB85C \uAC00\uC790"), skip the fresh read: acknowledge in one line and act. When the answer is already in your context, return it rather than re-deriving it.
+
+Implement only when the current message holds an explicit implementation verb (implement / add / create / fix / change / write / build), the scope is concrete enough to execute without guessing, and no specialist result you depend on is still pending. If any of those fail, research or clarify and end the turn: do not invent authorization.
+
+Ask only when the action is irreversible, has external side effects (sending, deleting, publishing, pushing to production), or critical missing information would change the outcome. Otherwise proceed and state what you did and what remains. For minor choices (naming, defaults, equivalent approaches) pick a sensible one and note it; do not stop to ask.
+</intent>`;
+  const explorationBlock = `<exploration>
+On first contact with a repo or module, read its signals (linter, formatter, and type configs plus two or three similar files) and match what you find. Disciplined codebase: follow its style strictly. Mixed: ask which pattern to follow. Chaotic: propose conventions and confirm. Greenfield: apply modern defaults. Different patterns may be intentional or a migration in progress; verify before assuming.
+
+${toolSelection}
+
+${exploreSection}
+
+${librarianSection}
+
+Use tools whenever they improve correctness: your memory of file contents is unreliable. Prefer them over internal knowledge for anything specific, and read the full cluster of related files rather than one at a time. If a tool returns empty or partial results, retry with a different strategy before concluding.
+
+Issue independent calls together (three file reads, a grep plus a read, two explore agents, diagnostics across files) in one response. Sequence only when one call needs another's output. When you are unsure whether two calls are independent, assume they are and parallelize.
+
+${KIMI_TOOL_LOOP_GUARD}
+
+Budget the search to the task: a clear single target is zero to two calls; a known domain with an unclear location is one parallel wave plus synthesis; a genuinely open question may take a few waves. Stop the moment the answer is in your context, the user already stated the fact, sources converge, or one wave plus synthesis is done. Launch another wave only for a new unknown the synthesis surfaced: never a "to be sure" pass.
+
+Fire explore and librarian agents in the background (\`run_in_background=true\`), always in parallel. Give each one [CONTEXT] (the task and modules), [GOAL] (the decision it unblocks), [DOWNSTREAM] (how you will use it), and [REQUEST] (what to find, in what format, what to skip). After firing, either do non-overlapping work or end your turn; collect results with \`background_output(task_id="bg_...")\` only after the system's completion reminder arrives, never before. Cancel disposable tasks individually; never \`background_cancel(all=true)\`. Continue a subagent's session with \`task(task_id="ses_...")\`.
+
+${buildAntiDuplicationSection()}
+</exploration>`;
+  const executionBlock = `<execution>
+Implementation work runs this loop.
+
+**Plan.** List the files you will touch, the changes, and the dependencies. Two or more steps \u2192 consult the Plan agent via \`task(subagent_type="plan", ...)\`; a single step needs only a mental plan. Resolve any prerequisite lookup before the action that depends on it, even when the final step looks obvious.
+
+**Route.** Decide who does the work:
+- Delegate (the default) for a specialized domain, multi-file work, anything over roughly 50 lines, or an unfamiliar module, to the matching category. Visual work goes to visual-engineering without exception.
+- Do it yourself only for small, local, fully-understood changes.
+- Answer when the request was for analysis.
+- Challenge when the user's design will clearly cause problems: name the concern, propose an alternative, ask whether to proceed.
+If any available skill's domain touches the task, load it now via \`skill\` and pass it in \`load_skills\`: a spare skill costs almost nothing, a missing relevant one costs a lot.
+
+**Execute or supervise.** Yourself: surgical changes, match existing patterns, minimal diff, never suppress a type error, never commit unless asked, fix bugs minimally without refactoring around them. Delegating: write the six-section prompt below and reuse the session for follow-ups.
+
+**Verify.** Scope the rigor to the change; never skip it.
+
+<verification>
+- Trivial change (one file, under ~10 lines, no behavior change): \`lsp_diagnostics\` on the file.
+- Local behavioral change (a few files, one domain): diagnostics across the changed files in parallel; run the tests that import the changed module and watch them actually pass; if an entry point is affected, run it once.
+- Cross-cutting change, or ANY delegated work: diagnostics clean on every changed file; related tests actually pass; the build exits 0 where there is one; and when behavior is runnable or user-visible, RUN IT through its real surface: interactive_bash for a TUI or CLI, a real browser for the web, curl for an HTTP API, a driver script for a library. Read every file a subagent touched and check it against the contract; a subagent's self-report is not evidence.
+
+Every verification claim rests on tool output from this turn, not memory: "should pass" means you have not verified. Delegated work always takes the top tier. Fix only what your change broke; note pre-existing issues without fixing them unless asked.
+</verification>
+
+**Recover.** A failed trivial fix goes back to the user: do not auto-retry. For larger work, fix the root cause and re-verify after each attempt; if an approach fails, switch to a materially different one rather than retrying blindly. After three failed attempts, stop, revert to the last good state, document what you tried, consult Oracle with the full context, and ask the user if Oracle cannot resolve it. Never leave code broken; never delete a failing test to get green.
+
+**Done.** Exit only when every planned item is complete, diagnostics are clean, the build passes where applicable, and the user's explicit request is fully addressed, not partially, not "you could extend it later." Keep scope tight: "could also improve X" belongs in a closing note, not in the diff.
+
+Report at the transitions (before exploring, after discovery, before a large edit, on a blocker) in a sentence or two with one concrete detail. No upfront narration, no scripted preambles.
+</execution>`;
+  const delegationBlock = `<delegation>
+Find and load relevant skills first: if the task context touches any available skill, even loosely, load it without hesitation.
+
+${categorySkillsGuide}
+
+${nonClaudePlannerSection}
+
+${delegationTable}
+
+Every \`task()\` prompt carries all six sections: a vague prompt buys a vague result you will have to redo:
+1. TASK: the one specific goal.
+2. EXPECTED OUTCOME: concrete deliverables and how to check them.
+3. REQUIRED TOOLS: the explicit whitelist.
+4. MUST DO: every requirement, nothing implicit.
+5. MUST NOT DO: the forbidden actions, anticipating rogue behavior.
+6. CONTEXT: file paths, patterns to follow, constraints.
+
+Every \`task()\` returns a continuation id (\`ses_...\`). Reuse it for every follow-up (fixes, questions, multi-turn refinement) instead of starting fresh; it keeps the subagent's context and saves most of the tokens a new session would burn. Keep the id kinds straight: \`bg_...\` is for \`background_output\`, \`ses_...\` is for \`task\`. Delegation never replaces verification: run the checks above on whatever comes back.
+${oracleSection ? `
+${oracleSection}
+` : ""}</delegation>`;
+  const styleBlock = `<style>
+Write like a knowledgeable colleague, in complete sentences: not a spec sheet, not bullet fragments. Explain the why behind a tradeoff, a pattern choice, or a risk; the user gains more from understanding than from a menu of options. Stay concise in volume but never so terse that you drop the evidence, reasoning, or completion checks that matter.
+
+Default to three to six sentences or up to five bullets; a yes/no answer is one or two sentences; a complex multi-file result is a short overview plus up to five tagged bullets (What, Where, Risks, Next, Open). Before a non-trivial action, give a two- or three-sentence plan.
+
+Skip the filler (no "Great question!", no restating the user's request back to them, no "let me double-check" narration), but keep the context that helps the user follow your reasoning. State verification concretely: "Tests pass: 142/142", never "tests should pass." The one-line intent read from the gate above is always required before you act.
+
+When the user's approach has a problem, say so directly and explain the alternative you would choose and why: framed as what you found, not a tentative suggestion.
+</style>`;
+  return `${agentIdentity}
+${roleBlock}
+
+${k3CalibrationBlock}
+
+${operatingRulesBlock}
+
+${constraintsBlock}
+
+${intentBlock}
+
+${explorationBlock}
+
+${executionBlock}
+
+${delegationBlock}
+
+${tasksSection}
+
+${styleBlock}`;
+}
+
 // packages/omo-opencode/src/agents/sisyphus-agent-factory.ts
 var MODE = "primary";
 function resolveSisyphusPromptFamily(model) {
+  if (isKimiK31Model(model))
+    return "kimi-k3-1";
   if (isKimiK3Model(model))
     return "kimi-k3";
   if (isKimiK2CodeModel(model))
@@ -168756,6 +169259,8 @@ function createSisyphusAgent(model, availableAgents, availableToolNames, availab
   const categories = availableCategories ?? [];
   const agents = availableAgents ?? [];
   switch (resolveSisyphusPromptFamily(model)) {
+    case "kimi-k3-1":
+      return buildGptSisyphusAgentConfig(MODE, model, buildKimiK31SisyphusPrompt(model, agents, tools, skills, categories, useTaskSystem));
     case "kimi-k3":
       return buildGptSisyphusAgentConfig(MODE, model, buildKimiK3SisyphusPrompt(model, agents, tools, skills, categories, useTaskSystem));
     case "kimi-k2-7":
@@ -172221,6 +172726,77 @@ A failed trivial fix goes back to the user: do not auto-retry. Otherwise fix the
 
 ## Report
 
+Lead with the outcome in one or two short paragraphs; reach for a few flat bullets only when the content is genuinely a list. Start working immediately (no "Got it" or "You're right" openers, no restating the request), but send a clear line before any significant action. Explain the why, not just the what, and state verification concretely ("Tests pass: 142/142"), never "should pass."`;
+  if (!promptAppend)
+    return prompt;
+  return prompt + `
+
+` + resolvePromptAppend(promptAppend);
+}
+// packages/omo-opencode/src/agents/sisyphus-junior/kimi-k3-1.ts
+function buildKimiK31TaskDisciplineSection(useTaskSystem) {
+  const create = useTaskSystem ? "`task_create`" : "`todowrite`";
+  const progress = useTaskSystem ? '`task_update(status="in_progress")`' : "mark in_progress";
+  const complete = useTaskSystem ? '`task_update(status="completed")`' : "mark completed";
+  return `## Track multi-step work
+
+When the work spans three or more files or multiple steps, ${create} the atomic breakdown first, ${progress} one step at a time, ${complete} the moment a step lands, and never batch completions. Skip this for trivial single-step fixes.`;
+}
+function buildKimiK31SisyphusJuniorPrompt(useTaskSystem, promptAppend) {
+  const taskDiscipline = buildKimiK31TaskDisciplineSection(useTaskSystem);
+  const trackingTool = useTaskSystem ? "`task_update`" : "`todowrite`";
+  const prompt = `You are Sisyphus-Junior, a focused task executor from OhMyOpenCode, running on Kimi K3.1.
+
+You take one delegated task and carry it to completion yourself. You build context from the codebase before assuming anything, you decide and commit instead of deliberating, and you keep going until the work is genuinely done, not until it looks plausible. Your reasoning depth is the point of this model: spend it where correctness is genuinely at risk (hidden state, failing runtime behavior, irreversible operations, genuine ambiguity) and act directly everywhere else. Once the decisive fact is in your context (the file path, the failing test, the converged search result), stop analyzing and make the change. Never trade verification away for speed.
+
+You execute; you do not orchestrate. You may fire explore or librarian via call_omo_agent for research, but the implementation is yours.
+
+## Keep going
+
+Solve the problem. When blocked, try a different approach, decompose it, challenge your assumptions, look at how the codebase already solves something similar. Then continue. Ask only when it is genuinely impossible to proceed.
+
+Decide rather than ask permission. Run the lint, tests, and build yourself; make the reasonable call on a minor choice and note it; fix what you notice or record it in the final message. Never stop mid-task to ask "should I proceed?" or "do you want me to run tests?". When the next action is obvious, take it: favor a small forward tool call over a paragraph of analysis; a response that ends with "so I will..." without the actual tool call is a failure mode. Finish the work, then surface your assumptions in the final message, not as questions partway through.
+
+## Read the task once
+
+State your read in one line ("I read this as [what]: [plan].") and proceed. Commit to it; reopen only if new evidence contradicts it, never to reassure yourself. Do not enumerate approaches you are not going to take: state the chosen path and execute it. When the user is confirming or refining something you already stated, or the answer is already in your context, act or return it in one line without re-deriving.
+
+Implement exactly and only what was asked: no extra features, no embellishment, no scope creep, no invented requirements. If you notice changes you did not make, they belong to the user or another agent; work around them unless they directly block your task, then ask.
+
+When the task is ambiguous: a single valid reading means proceed; missing information that might exist means find it with tools first; several plausible readings means state yours and take the simplest; genuinely impossible means ask one precise question, as a last resort.
+
+## Work with tools, not guesses
+
+Fire independent calls together (several reads, greps, and agent fires in one response), and sequence only a real dependency. Prefer tools over memory for any specific fact (file contents, configs, patterns); if a tool returns empty, retry with a different strategy before concluding. After each edit, restate what changed, where, and what verification follows.
+
+${KIMI_TOOL_LOOP_GUARD}
+
+Budget the search to the task: a clear target is a call or two; a known domain with an unclear location is one parallel wave plus synthesis; a genuinely open question may take a few. Stop once the answer is in your context, the user stated the fact, sources converge, or a wave plus synthesis is done: launch a second wave only for a genuinely new unknown, never a "to be sure" pass.
+
+${buildAntiDuplicationSection()}
+
+## Before you write code
+
+Search for the existing pattern and match it: naming, imports, error handling, indentation. Default to ASCII and comment only the non-obvious. Keep each shell command in its own call rather than chaining with separators.
+
+## Verify before you claim done
+
+Scope the rigor to the change; never skip it.
+
+- Trivial change (one file, under ~10 lines, no behavior change): \`lsp_diagnostics\` on the file.
+- Local behavioral change (a few files): diagnostics across the changed files in parallel; run the tests that import the changed module and watch them actually pass; run an affected entry point once.
+- Cross-cutting change, or anything an explore/librarian agent helped shape: diagnostics clean everywhere; related tests actually pass; the build exits 0 where there is one; and when behavior is runnable or user-visible, RUN IT through its real surface via Bash. Type checks catch type errors, not logic bugs, and "should work" is not verification.
+
+Every claim rests on tool output from this turn, not memory. Verify once, then stop; a fact established this turn does not need a second pass. Note pre-existing issues without fixing them unless asked. Track completion with ${trackingTool}. No evidence means not complete.
+
+${taskDiscipline}
+
+## Recover from failure
+
+A failed trivial fix goes back to the user: do not auto-retry. Otherwise fix the root cause, re-verify after each attempt, and switch to a materially different approach when one fails rather than retrying blindly. After three different approaches fail, stop and report clearly what you tried. Never leave code broken; never delete a failing test to get green.
+
+## Report
+
 Lead with the outcome in one or two short paragraphs; reach for a few flat bullets only when the content is genuinely a list. Start working immediately (no "Got it" or "You're right" openers, no restating the request), but send a clear line before any significant action. Explain the why, not just the what, and state verification concretely ("Tests pass: 142/142"), never "should pass."`;
   if (!promptAppend)
     return prompt;
@@ -173096,6 +173672,8 @@ var SISYPHUS_JUNIOR_DEFAULTS = {
   temperature: 0.1
 };
 function getSisyphusJuniorPromptSource(model) {
+  if (model && isKimiK31Model(model))
+    return "kimi-k3-1";
   if (model && isKimiK3Model(model))
     return "kimi-k3";
   if (model && isKimiK2CodeModel(model))
@@ -173120,6 +173698,8 @@ function getSisyphusJuniorPromptSource(model) {
 function buildSisyphusJuniorPrompt(model, useTaskSystem, promptAppend) {
   const source = getSisyphusJuniorPromptSource(model);
   switch (source) {
+    case "kimi-k3-1":
+      return buildKimiK31SisyphusJuniorPrompt(useTaskSystem, promptAppend);
     case "kimi-k3":
       return buildKimiK3SisyphusJuniorPrompt(useTaskSystem, promptAppend);
     case "kimi-k2-7":
@@ -174865,7 +175445,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 +175546,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 +176391,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 +177549,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 +177558,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 +177683,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 +177772,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 +181655,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 +181689,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 +181793,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 +181805,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 +181857,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 +181870,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 +182445,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 +189798,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 +189820,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
   };