oh-my-opencode 5.0.0-beta.79 → 5.0.0-beta.80

package/dist/index.js

@@ -19738,13 +19738,8 @@ var CATEGORY_MODEL_REQUIREMENTS = {
       { providers: ["openai", "openai-codex", "opencode"], model: "gpt-5.6-sol", variant: "max" }
     ]
   },
-  deep: {
+  "deep-low": {
     fallbackChain: [
-      {
-        providers: ["openai", "openai-codex", "github-copilot", "opencode"],
-        model: "gpt-6-astra",
-        variant: "high"
-      },
       {
         providers: ["openai", "openai-codex", "github-copilot", "opencode"],
         model: "gpt-5.6-sol",
@@ -19752,6 +19747,15 @@ var CATEGORY_MODEL_REQUIREMENTS = {
       }
     ]
   },
+  "deep-high": {
+    fallbackChain: [
+      {
+        providers: ["openai", "openai-codex", "github-copilot", "opencode"],
+        model: "gpt-6-astra",
+        variant: "high"
+      }
+    ]
+  },
   artistry: {
     fallbackChain: [
       {
@@ -19838,12 +19842,17 @@ var CATEGORY_MODEL_REQUIREMENTS = {
       {
         providers: ["anthropic", "anthropic-api", "github-copilot", "opencode"],
         model: "claude-fable-5-1",
-        variant: "medium"
+        variant: "low"
       },
       {
         providers: ["kimi-for-coding", "moonshotai", "opencode-go", "opencode"],
         model: "kimi-k3",
-        variant: "max"
+        variant: "low"
+      },
+      {
+        providers: ["anthropic", "anthropic-api", "github-copilot", "opencode"],
+        model: "claude-opus-4-6",
+        variant: "low"
       }
     ]
   }
@@ -23212,6 +23221,65 @@ var OmoConfigLayerSchema = z14.object({
   legacy_migrations: z14.record(z14.string(), z14.unknown()).optional()
 }).strict();
 
+// packages/omo-config-core/src/schema/legacy-category-names.ts
+var LEGACY_CATEGORY_NAME_ALIASES = { deep: "deep-low" };
+function canonicalCategoryName(name) {
+  return Object.hasOwn(LEGACY_CATEGORY_NAME_ALIASES, name) ? LEGACY_CATEGORY_NAME_ALIASES[name] : name;
+}
+function isRecord10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function joinPath(path, segment) {
+  return [...path, segment].join(".");
+}
+function canonicalizeCategoriesRecord(categories, path, renames) {
+  const result = {};
+  for (const [name, definition] of Object.entries(categories)) {
+    const canonical = canonicalCategoryName(name);
+    if (canonical === name) {
+      result[name] = definition;
+      continue;
+    }
+    const dropped = Object.hasOwn(categories, canonical);
+    renames.push({ canonical, dropped, legacy: name, path: joinPath(path, name) });
+    if (!dropped)
+      result[canonical] = definition;
+  }
+  return result;
+}
+function canonicalizeValue(value, path, renames) {
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => canonicalizeValue(entry, [...path, String(index)], renames));
+  }
+  if (!isRecord10(value))
+    return value;
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "categories" && isRecord10(entry)) {
+      result[key] = canonicalizeCategoriesRecord(entry, [...path, key], renames);
+      continue;
+    }
+    if (key === "category" && typeof entry === "string") {
+      const canonical = canonicalCategoryName(entry);
+      if (canonical !== entry) {
+        renames.push({ canonical, dropped: false, legacy: entry, path: joinPath(path, key) });
+      }
+      result[key] = canonical;
+      continue;
+    }
+    result[key] = canonicalizeValue(entry, [...path, key], renames);
+  }
+  return result;
+}
+function canonicalizeLegacyCategoryNames(document) {
+  const renames = [];
+  const canonicalized = isRecord10(document) ? canonicalizeValue(document, [], renames) : {};
+  return { document: canonicalized, renames };
+}
+function hasLegacyCategoryNames(document) {
+  return canonicalizeLegacyCategoryNames(document).renames.length > 0;
+}
+
 // packages/omo-config-core/src/loader/loader.ts
 init_main();
 
@@ -23457,21 +23525,21 @@ function hasUnsafeUnrecognizedKey(issues) {
 function hasTamperedPrototype(value) {
   if (Array.isArray(value))
     return value.some((entry) => hasTamperedPrototype(entry));
-  if (!isRecord10(value))
+  if (!isRecord11(value))
     return false;
   const prototype = Object.getPrototypeOf(value);
   if (prototype !== Object.prototype && prototype !== null)
     return true;
   return Object.values(value).some((entry) => hasTamperedPrototype(entry));
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function containerAt(record, path) {
   let container = record;
   for (const segment of path) {
     const next = container[segment];
-    if (!isRecord10(next))
+    if (!isRecord11(next))
       return null;
     container = next;
   }
@@ -23573,6 +23641,15 @@ function readConfigSource(path, scope, fileSystem) {
     value: parsedRecord
   };
 }
+function legacyCategoryDiagnostic(path, renames) {
+  const detail = renames.map((rename) => rename.dropped ? `${rename.path} ignored because ${rename.canonical} is also configured` : `${rename.path} renamed to ${rename.canonical}`).join(", ");
+  return {
+    kind: "deprecated-keys",
+    message: `Deprecated category name in ${path}: ${detail}. Rename it; the alias is removed in a future release.`,
+    path,
+    issuePaths: renames.map((rename) => rename.path)
+  };
+}
 function loadOmoConfig(options = {}) {
   const fileSystem = options.fileSystem ?? DEFAULT_READ_FILE_SYSTEM;
   const cwd = options.cwd ?? process.cwd();
@@ -23591,8 +23668,12 @@ function loadOmoConfig(options = {}) {
     if (loaded.diagnostic !== undefined)
       diagnostics.push(loaded.diagnostic);
     if (loaded.value !== undefined) {
-      layers.push({ config: loaded.value, source: loaded.source });
-      merged = mergeOmoConfigRecords(merged, loaded.value);
+      const canonicalized = canonicalizeLegacyCategoryNames(loaded.value);
+      if (canonicalized.renames.length > 0) {
+        diagnostics.push(legacyCategoryDiagnostic(candidate.path, canonicalized.renames));
+      }
+      layers.push({ config: canonicalized.document, source: loaded.source });
+      merged = mergeOmoConfigRecords(merged, canonicalized.document);
     }
   }
   const requestedProfile = resolveOmoProfileName({
@@ -24608,6 +24689,9 @@ function executePlan(input) {
   const existingSources = plan.sources.filter((source) => fileSystem.existsSync(source.path));
   const target = targetDocument(plan.targetPath, fileSystem);
   const replaceTarget = plan.mode === "replace-target";
+  if (plan.shouldRun !== undefined && !plan.shouldRun(target)) {
+    return { diagnostics: [], journalResumed, status: "skipped" };
+  }
   if (!shouldRunMigration({
     legacySourcesExist: replaceTarget ? fileSystem.existsSync(plan.targetPath) : existingSources.length > 0,
     migrationId: plan.id,
@@ -25683,7 +25767,7 @@ function migrateRalphLoopConfig(config) {
 function validatePluginConfig(directory, environment = process.env) {
   const chain = loadOmoOpenCodeConfigChain(directory, environment);
   const views = chain.views.map((view) => parseConfigView(view.path, view.config));
-  const chainMessages = chain.diagnostics.map((diagnostic) => `${shortPath(diagnostic.path)}: ${diagnostic.message}`);
+  const chainMessages = chain.diagnostics.filter((diagnostic) => diagnostic.kind !== "deprecated-keys").map((diagnostic) => `${shortPath(diagnostic.path)}: ${diagnostic.message}`);
   const messages = [...chainMessages, ...views.flatMap((view) => view.messages)];
   const firstFailingView = views.find((view) => view.messages.length > 0);
   const firstView = views[0];
@@ -26362,7 +26446,7 @@ ANTI-AI-SLOP RULES (NON-NEGOTIABLE):
 var KIMI_CATEGORIES = [
   {
     name: "writing",
-    config: { model: "anthropic/claude-fable-5-1", variant: "medium" },
+    config: { model: "anthropic/claude-fable-5-1", variant: "low" },
     description: "Documentation, prose, technical writing",
     promptAppend: WRITING_CATEGORY_PROMPT_APPEND
   }
@@ -26410,14 +26494,24 @@ Success means:
 
 Whatever that check leaves unsettled goes in the answer as an open question with what would settle it. When the goal bundles independent problems, solve the one the others depend on and return the rest as separately delegable items.
 </Category_Context>`;
-var DEEP_CATEGORY_PROMPT_APPEND_GPT_6_ASTRA = `<Category_Context name="deep">
-The orchestrator routed this task here for depth: one goal, one deliverable, and the time to earn it. The exploration budget is generous: read every file involved, trace callers and dependencies in both directions, and fan out explore and librarian subagents in parallel for the questions a single read wave cannot answer, until you can explain the full mechanism you are about to change; an edit made before that point is the failure this category exists to prevent.
-
-**MUST USE \`deep\` FOR 3D GRAPHICS, COMPUTER USE, BROWSER USE, BACKEND, LOGIC, ALGORITHMS, CAPTCHA SOLVING, AND MULTIMODAL WORK.**
+var DEEP_HIGH_CATEGORY_PROMPT_APPEND_GPT = `<Category_Context name="deep-high">
+The orchestrator routed this task here because a decision in it cannot be settled from evidence alone: a trade-off, a contract other code depends on, a mechanism with no pattern to copy, or correctness that has to be argued. One goal, one deliverable, and the time to earn it. The exploration budget is generous: read every file involved, trace callers and dependencies in both directions, and fan out explore and librarian subagents in parallel for the questions a single read wave cannot answer, until you can explain the full mechanism you are about to change; an edit made before that point is the failure this category exists to prevent.
 
 The goal is the authorization. Choose how to reach it yourself, and when it lists numbered steps or phases, deliver all of them in this turn as one task; a proposal, a plan awaiting approval, a simplified version, or a proof of concept is unfinished work. When the steps turn out to be independent problems sharing no reasoning, do the one the goal centers on and return the others as separately delegable items with what you learned. A question ends your turn and hands the task back unfinished, so decide from context, record each assumption in the final message, and stop early only for a blocker you cannot route around: a missing secret, a decision only the user can make, or three materially different attempts that all failed.
 
-Fix the cause: trace at least two levels above the symptom before settling, and prefer the change that makes the failure impossible over the guard that hides it. Depth means understanding the mechanism, so the diff stays as small as the fix allows; on greenfield work choose strong defaults and finish something you would hand to a senior engineer. Close with the delivered change, the evidence that it works, and the assumptions you made.
+Fix the cause: trace at least two levels above the symptom before settling, and prefer the change that makes the failure impossible over the guard that hides it. Depth means understanding the mechanism, so the diff stays as small as the fix allows; on greenfield work choose strong defaults and finish something you would hand to a senior engineer. Close with the delivered change, the evidence that it works, the decision you settled with the alternative you rejected, and the assumptions you made.
+</Category_Context>`;
+var DEEP_LOW_CATEGORY_PROMPT_APPEND_GPT = `<Category_Context name="deep-low">
+The orchestrator routed this task here as the default deep lane: one goal, one deliverable, decisions that the code, tests, and history can settle. Read until you can explain the mechanism you are about to change, including its callers, then act; fan out explore and librarian subagents when one read wave cannot answer a question.
+
+Success means:
+- every step or phase the goal lists is delivered in this turn as one task; a plan awaiting approval, a simplified version, or a proof of concept is unfinished work;
+- the change removes the cause you traced, at least two levels above the symptom, with the diff as small as that fix allows;
+- the final message reports the change, the evidence that it works, and each assumption you decided from context, because a question ends your turn and returns the task unfinished.
+
+Escalation is a complete result. When the correct choice turns out to depend on a trade-off the brief does not settle, on a contract other packages rely on, or on an argument about invariants you cannot verify by running something, stop before editing and return \`ESCALATE: deep-high\` as the first line, followed by what you read, the decision you could not settle, and the options you saw. A confident guess through that decision costs more than the escalation.
+
+Stop the moment the success criteria hold; work past them is a defect. Stop early only for a blocker you cannot route around: a missing secret, a decision only the user can make, or three materially different attempts that all failed.
 </Category_Context>`;
 var UNSPECIFIED_HIGH_CATEGORY_PROMPT_APPEND_GPT_6_ASTRA = `<Category_Context name="unspecified-high">
 The orchestrator routed this task here because it spans systems or modules and fits no specialist category, so breadth of consideration is what this category buys. Before committing to an approach, survey the whole surface the change touches: every caller and consumer of what you will modify, sibling modules that implement the same pattern, the tests, docs, schemas, config, scripts, and CI that encode the current behavior, and the history of the area (git log and blame) for the reasons it is shaped this way. Fan out explore and librarian subagents in parallel when that surface is wider than one read wave covers.
@@ -26445,65 +26539,40 @@ Response format:
 - Action plan (numbered steps)
 - Risks and mitigations (if relevant)
 </Category_Context>`;
-var DEEP_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on GOAL-ORIENTED AUTONOMOUS tasks.
-
-You are NOT an interactive assistant. You are an autonomous problem-solver.
-
-**MUST USE \`deep\` FOR 3D GRAPHICS, COMPUTER USE, BROWSER USE, BACKEND, LOGIC, ALGORITHMS, CAPTCHA SOLVING, AND MULTIMODAL WORK.**
-
-BEFORE making ANY changes:
-1. Silently explore the codebase extensively (5-15 minutes of reading is normal)
-2. Read related files, trace dependencies, understand the full context
-3. Build a complete mental model of the problem space
-4. Do not ask clarifying questions - the goal is already defined
+var DEEP_LOW_CATEGORY_PROMPT_APPEND = `<Category_Context name="deep-low">
+You are working on a GOAL-ORIENTED AUTONOMOUS task: one goal, one deliverable, decisions the codebase can settle.
 
-You receive a GOAL. When the goal includes numbered steps or phases, treat them as one atomic task broken into sub-steps, not as separate independent tasks. Figure out HOW to achieve it yourself. Thorough research before any action.
+Before any change, read the files involved and trace their dependencies until you can explain the mechanism you are about to modify. The goal is already defined: do not ask clarifying questions; make reasonable assumptions, record them in the final message, and proceed.
 
-Sub-steps of ONE goal = execute all steps as phases of one atomic task.
-Genuinely independent tasks = flag and refuse, require separate delegations.
+When the goal lists numbered steps or phases, execute all of them in this turn as one atomic task. Genuinely independent tasks bundled into one goal: flag them and do only the one the goal centers on.
 
-Approach: explore extensively, understand deeply, then act decisively. Prefer comprehensive solutions over quick patches. If the goal is unclear, make reasonable assumptions and proceed.
+Escalation is a complete result. When the correct choice depends on a trade-off the brief does not settle, a contract other packages rely on, or an argument about invariants you cannot verify by running something, stop before editing and return \`ESCALATE: deep-high\` as the first line, followed by what you read, the decision you could not settle, and the options you saw.
 
-Minimal status updates. Focus on results, not play-by-play. Report completion with summary of changes.
+Prefer the fix that removes the cause over the patch that hides the symptom. Report completion with the changes made and the evidence they work.
 </Category_Context>`;
-var DEEP_CATEGORY_PROMPT_APPEND_GPT_5_5 = `<Category_Context name="deep">
-You are operating in DEEP mode. This is the category reserved for goal-oriented autonomous work on hairy problems that reward thorough exploration and comprehensive solutions.
-
-**MUST USE \`deep\` FOR 3D GRAPHICS, COMPUTER USE, BROWSER USE, BACKEND, LOGIC, ALGORITHMS, CAPTCHA SOLVING, AND MULTIMODAL WORK.**
-
-The orchestrator chose this category because the task benefits from depth over speed. You should feel empowered to spend the time needed: five to fifteen minutes of silent exploration before the first edit is normal and correct. Rushing to implementation on a deep task is a failure mode, not a feature.
-
-# How deep mode adjusts the base behavior
-
-**Exploration budget: generous.** Read the files you need, trace dependencies both directions, fire 2-5 explore/librarian sub-agents in parallel for broader questions. Build a complete mental model before the first \`apply_patch\`. Exploration here is an investment, not overhead.
+var DEEP_HIGH_CATEGORY_PROMPT_APPEND = `<Category_Context name="deep-high">
+You are working on a GOAL-ORIENTED AUTONOMOUS task that was escalated here because a decision in it cannot be settled from evidence alone: a trade-off, a contract other code depends on, a mechanism with no pattern to copy, or correctness that has to be argued.
 
-**Goal, not plan.** You receive a GOAL describing the desired outcome. You figure out HOW to achieve it. The orchestrator deliberately did not hand you a step-by-step plan; producing one and asking for approval is not what was asked. Execute.
+Before any change, read the files involved and trace their dependencies until you can explain the mechanism you are about to modify. The goal is already defined: do not ask clarifying questions; make reasonable assumptions, record them in the final message, and proceed.
 
-**Atomic task treatment.** When the goal contains numbered steps or phases, treat them as sub-steps of ONE task and execute them all in this turn. Splitting them across turns is wrong unless they reveal an architectural blocker that requires the user's input. If the "steps" turn out to be genuinely independent tasks that should have been separate delegations, flag that in your final message and refuse the ones beyond scope.
+When the goal lists numbered steps or phases, execute all of them in this turn as one atomic task. Genuinely independent tasks bundled into one goal: flag them and do only the one the goal centers on.
 
-**Root cause bias.** Prefer root-cause fixes over symptom fixes. A null check around \`foo()\` is a symptom fix; fixing whatever causes \`foo()\` to return unexpected values is the root fix. Trace at least two levels up before settling on an answer. In deep mode, you have permission (and the expectation) to do the deeper fix.
-
-**Ambition scaled to context.** For brand-new greenfield work, be ambitious. Choose strong defaults, avoid AI-slop aesthetics, produce something you would be proud to hand to another senior engineer. For changes in an existing codebase, be surgical and respect the existing patterns; depth does not mean invasiveness.
-
-**Completion bar: full delivery.** "Simplified version", "proof of concept", and "you can extend this later" are not acceptable deliveries for a deep task. The orchestrator routed here specifically for a complete solution. If you hit a genuine blocker (missing secret, design decision only the user can make, three materially different attempts all failed), document it and return; otherwise, finish the task.
-
-**Status cadence: sparse.** The user is not on the other side of this conversation; the orchestrator is, and they will synthesize your progress. Send commentary only at meaningful phase transitions (starting exploration, starting implementation, starting verification, hitting a genuine blocker). Do not narrate every tool call; silence during focused work is expected.
+Prefer the fix that removes the cause over the patch that hides the symptom. Report completion with the changes made, the evidence they work, and the decision you settled with the alternative you rejected.
 </Category_Context>`;
+function isGptDeepLaneModel(model) {
+  return model !== undefined && (isGpt6Model(model) || isGpt5_5Model(model) || isGpt5_6Model(model));
+}
 function resolveUltrabrainCategoryPromptAppend(model) {
   if (model && isGpt6Model(model)) {
     return ULTRABRAIN_CATEGORY_PROMPT_APPEND_GPT_6_ASTRA;
   }
   return ULTRABRAIN_CATEGORY_PROMPT_APPEND;
 }
-function resolveDeepCategoryPromptAppend(model) {
-  if (model && isGpt6Model(model)) {
-    return DEEP_CATEGORY_PROMPT_APPEND_GPT_6_ASTRA;
-  }
-  if (model && (isGpt5_5Model(model) || isGpt5_6Model(model))) {
-    return DEEP_CATEGORY_PROMPT_APPEND_GPT_5_5;
-  }
-  return DEEP_CATEGORY_PROMPT_APPEND;
+function resolveDeepLowCategoryPromptAppend(model) {
+  return isGptDeepLaneModel(model) ? DEEP_LOW_CATEGORY_PROMPT_APPEND_GPT : DEEP_LOW_CATEGORY_PROMPT_APPEND;
+}
+function resolveDeepHighCategoryPromptAppend(model) {
+  return isGptDeepLaneModel(model) ? DEEP_HIGH_CATEGORY_PROMPT_APPEND_GPT : DEEP_HIGH_CATEGORY_PROMPT_APPEND;
 }
 function resolveUnspecifiedHighCategoryPromptAppend(model) {
   if (model && isGpt6Model(model)) {
@@ -26535,7 +26604,10 @@ var UNSPECIFIED_HIGH_CATEGORY_PROMPT_APPEND = `<Category_Context>
 You are working on tasks that don't fit specific categories but require substantial effort.
 </Category_Context>`;
 var UNSPECIFIED_HIGH_CATEGORY_CALLER_GUIDANCE = `<Selection_Gate>Use only when no specialist category fits and substantial effort spans systems/modules with broad impact. Use unspecified-low for contained moderate work.</Selection_Gate>`;
-var GPT_FLAGSHIP_GATE_MODELS = ["gpt-6-astra", "gpt-5.6-sol"];
+var DEEP_LOW_CATEGORY_CALLER_GUIDANCE = `<Selection_Gate>Route here when one subsystem plus its callers holds the mechanism and the evidence, once read, leaves one right answer. Wide but mechanical work belongs here or in a quick batch. When unsure, choose deep-low: a misrouted child returns \`ESCALATE: deep-high\` after one cheap attempt; re-spawn the same brief as deep-high with its findings.</Selection_Gate>`;
+var DEEP_HIGH_CATEGORY_CALLER_GUIDANCE = `<Selection_Gate>Route here only when you can name the decision evidence cannot settle: a trade-off with no single right answer, a contract change crossing a package or process boundary, a mechanism with no in-repo pattern to copy, or correctness argued from invariants rather than observed in a test. Wide scope with easy decisions is deep-low or unspecified-high; reasoning as the deliverable is ultrabrain.</Selection_Gate>`;
+var DEEP_LOW_GATE_MODEL = "gpt-5.6-sol";
+var DEEP_HIGH_GATE_MODEL = "gpt-6-astra";
 var OPENAI_CATEGORIES = [
   {
     name: "ultrabrain",
@@ -26545,12 +26617,22 @@ var OPENAI_CATEGORIES = [
     resolvePromptAppend: resolveUltrabrainCategoryPromptAppend
   },
   {
-    name: "deep",
+    name: "deep-low",
+    config: { model: "openai/gpt-5.6-sol", variant: "medium" },
+    description: "Default deep lane: one goal, one deliverable, decisions the child can settle from what it reads. **3D graphics, computer/browser use, CAPTCHA, multimodal, backend, logic, and algorithm work is routed here.** Multiple goals fan out as parallel calls.",
+    callerGuidance: DEEP_LOW_CATEGORY_CALLER_GUIDANCE,
+    promptAppend: DEEP_LOW_CATEGORY_PROMPT_APPEND,
+    resolvePromptAppend: resolveDeepLowCategoryPromptAppend,
+    requiresModel: DEEP_LOW_GATE_MODEL
+  },
+  {
+    name: "deep-high",
     config: { model: "openai/gpt-6-astra", variant: "high" },
-    description: "**MANDATORY: USE deep FOR 3D GRAPHICS, COMPUTER USE, BROWSER USE, BACKEND, LOGIC, ALGORITHMS, CAPTCHA SOLVING, AND MULTIMODAL WORK.** Deep autonomous problem-solving for complex research. ONE goal + ONE deliverable per call \u2014 multiple goals must fan out as parallel `deep` calls, never bundled into one.",
-    promptAppend: DEEP_CATEGORY_PROMPT_APPEND,
-    resolvePromptAppend: resolveDeepCategoryPromptAppend,
-    requiresModel: GPT_FLAGSHIP_GATE_MODELS
+    description: "Escalation deep lane: a goal whose central decision cannot be settled from evidence alone. Same one-goal, one-deliverable contract as deep-low.",
+    callerGuidance: DEEP_HIGH_CATEGORY_CALLER_GUIDANCE,
+    promptAppend: DEEP_HIGH_CATEGORY_PROMPT_APPEND,
+    resolvePromptAppend: resolveDeepHighCategoryPromptAppend,
+    requiresModel: DEEP_HIGH_GATE_MODEL
   },
   {
     name: "quick",
@@ -96713,7 +96795,7 @@ function getCachedVersion(options = {}) {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "5.0.0-beta.79",
+  version: "5.0.0-beta.80",
   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",
@@ -96895,7 +96977,7 @@ var package_default = {
     zod: "^4.4.3"
   },
   devDependencies: {
-    "@code-yeongyu/senpi": "2026.9.19-2",
+    "@code-yeongyu/senpi": "2026.9.20",
     "@oh-my-opencode/agents-md-core": "workspace:*",
     "@oh-my-opencode/ast-grep-mcp": "workspace:*",
     "@oh-my-opencode/boulder-state": "workspace:*",
@@ -96934,18 +97016,18 @@ var package_default = {
     typescript: "^7.0.2"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "5.0.0-beta.79",
-    "oh-my-opencode-darwin-x64": "5.0.0-beta.79",
-    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.79",
-    "oh-my-opencode-linux-arm64": "5.0.0-beta.79",
-    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.79",
-    "oh-my-opencode-linux-x64": "5.0.0-beta.79",
-    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.79",
-    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.79",
-    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.79",
-    "oh-my-opencode-windows-arm64": "5.0.0-beta.79",
-    "oh-my-opencode-windows-x64": "5.0.0-beta.79",
-    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.79"
+    "oh-my-opencode-darwin-arm64": "5.0.0-beta.80",
+    "oh-my-opencode-darwin-x64": "5.0.0-beta.80",
+    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.80",
+    "oh-my-opencode-linux-arm64": "5.0.0-beta.80",
+    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.80",
+    "oh-my-opencode-linux-x64": "5.0.0-beta.80",
+    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.80",
+    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.80",
+    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.80",
+    "oh-my-opencode-windows-arm64": "5.0.0-beta.80",
+    "oh-my-opencode-windows-x64": "5.0.0-beta.80",
+    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.80"
   },
   overrides: {
     "@earendil-works/pi-agent-core": "0.84.2",
@@ -97762,6 +97844,16 @@ function transformReasoningUnification(document) {
   };
 }
 
+// packages/omo-opencode/src/config-migration/category-deep-split.ts
+var CATEGORY_DEEP_SPLIT_MIGRATION_ID = "2026-09-category-deep-split";
+function transformCategoryDeepSplit(document) {
+  const { document: canonicalized, renames } = canonicalizeLegacyCategoryNames(document);
+  return {
+    diagnostics: renames.map((rename) => rename.dropped ? `${rename.path} removed: ${rename.canonical} is already configured` : `${rename.path} renamed to ${rename.canonical}`),
+    document: canonicalized
+  };
+}
+
 // packages/omo-opencode/src/config-migration/migration-plans.ts
 function backupTimestamp(value) {
   return value ?? new Date().toISOString().replace(/[:.]/g, "-");
@@ -97828,6 +97920,18 @@ function reasoningPlan(targetPath) {
     transform: inspect
   };
 }
+function categoryDeepSplitPlan(targetPath) {
+  const inspect = (sources) => transformCategoryDeepSplit(sources[0]?.value);
+  return {
+    id: CATEGORY_DEEP_SPLIT_MIGRATION_ID,
+    inspect,
+    mode: "replace-target",
+    shouldRun: hasLegacyCategoryNames,
+    sources: [],
+    targetPath,
+    transform: inspect
+  };
+}
 function existingOmoConfigPath(directory, options) {
   const fileSystem = discoveryFileSystem(options);
   for (const fileName of ["omo.jsonc", "omo.json"]) {
@@ -97887,7 +97991,12 @@ function createLegacyConfigMigrationPlans(options) {
   }
   for (const plan of legacyPlans)
     addReasoningTarget(plan.targetPath);
-  return [...legacyPlans, ...[...reasoningTargets.values()].map(reasoningPlan)];
+  const inPlaceTargets = [...reasoningTargets.values()];
+  return [
+    ...legacyPlans,
+    ...inPlaceTargets.map(reasoningPlan),
+    ...inPlaceTargets.map(categoryDeepSplitPlan)
+  ];
 }
 // packages/omo-opencode/src/startup-migration.ts
 function homeDirectory(options) {
@@ -100105,7 +100214,7 @@ Everything else is parallel. Fire one \`task()\` per independent checkbox in the
 
 \`\`\`typescript
 task(category="quick", load_skills=[], run_in_background=false, prompt="...task A...")
-task(category="deep", load_skills=["programming"], run_in_background=false, prompt="...task B...")
+task(category="deep-low", load_skills=["programming"], run_in_background=false, prompt="...task B...")
 task(category="quick", load_skills=["git-master"], run_in_background=false, prompt="...task C...")
 \`\`\`
 
@@ -105401,7 +105510,7 @@ REQUIRED NOW:
 - Ask Oracle to verify whether the original task is actually complete
 - Include the original task in the Oracle request
 - Explicitly tell Oracle to review skeptically and critically, and to look for reasons the task may still be incomplete or wrong
-- If the Oracle spawn fails because its model/agent is unavailable, spawn a verifier with the identical verification instructions using task(category: "deep", load_skills=[], run_in_background=false, ...), then retry with category: "unspecified-high", then category: "unspecified-low" on the same failure; require its reply to end with the literal line \`Agent: gate-verifier\` immediately above the promise tag
+- If the Oracle spawn fails because its model/agent is unavailable, spawn a verifier with the identical verification instructions using task(category: "deep-high", load_skills=[], run_in_background=false, ...), then retry with category: "deep-low", then category: "unspecified-high", then category: "unspecified-low" on the same failure; require its reply to end with the literal line \`Agent: gate-verifier\` immediately above the promise tag
 - The system will inspect the Oracle session directly for the verification result
 - If Oracle does not verify, continue fixing the task and do not consider it complete
 
@@ -105417,7 +105526,7 @@ REQUIRED NOW:
 - Do not claim completion early or argue with the failed verification
 - After fixing the remaining issues, request Oracle review again using task(subagent_type="oracle", load_skills=[], run_in_background=false, ...)
 - Include the original task in the Oracle request and tell Oracle to review skeptically and critically
-- If the Oracle spawn fails because its model/agent is unavailable, spawn a verifier with the identical verification instructions using task(category: "deep", load_skills=[], run_in_background=false, ...), then retry with category: "unspecified-high", then category: "unspecified-low" on the same failure; require its reply to end with the literal line \`Agent: gate-verifier\` immediately above the promise tag
+- If the Oracle spawn fails because its model/agent is unavailable, spawn a verifier with the identical verification instructions using task(category: "deep-high", load_skills=[], run_in_background=false, ...), then retry with category: "deep-low", then category: "unspecified-high", then category: "unspecified-low" on the same failure; require its reply to end with the literal line \`Agent: gate-verifier\` immediately above the promise tag
 - Only when the work is ready for review again, output: <promise>{{PROMISE}}</promise>
 
 Original task:
@@ -110385,7 +110494,7 @@ Read the Team Staffing Recommendation from Phase 4. If any required field is mis
 
 Then choose the path:
 
-- **Team path (5.1-T)**: when the plan recommends \`team\` AND \`file_independent_steps >= 3\`. Members execute in parallel, Lead orchestrates, a \`deep\` verifier lives outside the team.
+- **Team path (5.1-T)**: when the plan recommends \`team\` AND \`file_independent_steps >= 3\`. Members execute in parallel, Lead orchestrates, a \`deep-high\` verifier lives outside the team.
 - **Legacy path (5.1-L)**: otherwise. Use the original 5.1 / 5.2 / 5.3 flow from above.
 
 Record the chosen path in the TodoWrite list.
@@ -110423,7 +110532,7 @@ Record the chosen path in the TodoWrite list.
 
 Rationale for this composition:
 - **4 workers = team mode's parallel cap.** 5+ just queues.
-- **No verifier team member.** Verification needs \`deep\` reasoning (or \`unspecified-high\` fallback). In-team category routing downcasts to sisyphus-junior, which is weaker than required \u2014 the verifier runs OUTSIDE the team as a \`task(category="deep")\`.
+- **No verifier team member.** Verification needs \`deep-high\` reasoning (or \`unspecified-high\` fallback). In-team category routing downcasts to sisyphus-junior, which is weaker than required \u2014 the verifier runs OUTSIDE the team as a \`task(category="deep-high")\`.
 - **quick \xD7 2** for mechanical edits, **unspecified-low \xD7 2** for reasoning edits \u2014 mirrors the plan's split.
 
 **Team lifecycle** (one team, reused until Phase 6 cleanup):
@@ -110455,14 +110564,14 @@ While any team task is \`pending | claimed | in_progress\`:
 - On a worker completion report, immediately dispatch an **external verifier** \u2014 verification runs OUTSIDE the team because team-member category routing downcasts to sisyphus-junior:
   \`\`\`
   task(
-    category="deep",
+    category="deep-high",
     load_skills=[],
     run_in_background=true,
     description="verify step <N>",
     prompt=<files touched + verify-spec commands + instruction to return "PASS" or "FAIL:<failing test + specific error + suggested revert hunks>">
   )
   \`\`\`
-  If \`deep\` is unavailable, fall back to \`category="unspecified-high"\`. Do not create a commit checkpoint until the verifier returns PASS.
+  If \`deep-high\` is unavailable, fall back to \`category="unspecified-high"\`. Do not create a commit checkpoint until the verifier returns PASS.
 - On a verifier PASS: make the commit checkpoint for that step (see original 5.3). Proceed.
 - On a verifier FAIL: Lead decides:
   - **Retry with fix hint**: \`team_task_update(status=pending)\` on the original step + \`team_send_message(teamRunId=<id>, to=<original member>, summary="retry", body=<specific failure from verifier>)\`. Runtime reassigns.
@@ -110489,7 +110598,7 @@ Append to the 6.6 summary a "Dispatch path" line and, when team path was used, t
 - Do not inline the Intent Card or verify-spec into task descriptions \u2014 rely on the broadcasts.
 - Do not recreate the team mid-session.
 - Do not run tests from Lead \u2014 the external verifier owns that lane.
-- Do not put \`oracle\` / \`librarian\` / \`deep\` into the team spec \u2014 oracle/librarian are team-ineligible, and \`deep\` under category routing downcasts to sisyphus-junior. Use them via \`task()\` outside the team when needed.
+- Do not put \`oracle\` / \`librarian\` / a deep lane into the team spec \u2014 oracle/librarian are team-ineligible, and a deep lane under category routing downcasts to sisyphus-junior. Use them via \`task()\` outside the team when needed.
 `;
 
 // packages/omo-opencode/src/features/builtin-commands/templates/refactor.ts
@@ -110988,7 +111097,7 @@ Team mode is enabled for this session. The rules below **override Phase 2-4** of
 
 Rationale for this composition:
 - **4 workers = team mode's parallel cap.** A fifth member just queues.
-- **Reviewer is NOT a team member** \u2014 review demands stronger reasoning than category routing provides (team category members are downcast to sisyphus-junior). The reviewer runs OUTSIDE the team as a \`deep\` task; see Phase 3.
+- **Reviewer is NOT a team member** \u2014 review demands stronger reasoning than category routing provides (team category members are downcast to sisyphus-junior). The reviewer runs OUTSIDE the team as a \`deep-high\` task; see Phase 3.
 - **quick \xD7 3** absorbs the mass of per-file slop removal. **unspecified-low \xD7 1** is the rework lane for fixes triggered by reviewer findings.
 
 **Team lifecycle** (create once, reuse until Phase 5 cleanup):
@@ -111015,14 +111124,14 @@ While any team task is \`pending | claimed | in_progress\`:
   - Immediately dispatch an **external reviewer** \u2014 review runs OUTSIDE the team because team-member category routing downcasts to sisyphus-junior:
     \`\`\`
     task(
-      category="deep",
+      category="deep-high",
       load_skills=[],
       run_in_background=true,
       description="slop review: <file>",
       prompt=<file path + full worker report + Safety/Behavior/Quality checklist + instruction to output "PASS" or "FAIL:<per-hunk rollback instructions>">
     )
     \`\`\`
-    If \`deep\` is unavailable in this session, fall back to \`category="unspecified-high"\`.
+    If \`deep-high\` is unavailable in this session, fall back to \`category="unspecified-high"\`.
 - On a reviewer task returning FAIL:
   - Create a rework team task: \`team_task_create(subject="rework: <file>", description=<reverse-patch hunks from reviewer + "then run $omo:remove-ai-slops on remaining non-rolled-back issues only">)\`. The \`unspecified-low\` fix member claims it.
   - Create a new reviewer task paired to the rework completion (same incremental pattern).
@@ -111061,7 +111170,7 @@ skill(name="hyperplan")
 
 After loading the skill, follow its 7-phase workflow EXACTLY using this user request.
 
-Roster contract: call \`team_create\` with category members \`unspecified-low\`, \`unspecified-high\`, \`ultrabrain\`, and \`artistry\`. Include \`deep\` only if the category is enabled; if \`deep\` is disabled or unavailable, retry without only that member and state the degraded roster.
+Roster contract: call \`team_create\` with category members \`unspecified-low\`, \`unspecified-high\`, \`ultrabrain\`, and \`artistry\`. Include \`deep-low\` only if the category is enabled; if \`deep-low\` is disabled or unavailable, retry without only that member and state the degraded roster.
 
 <user-request>
 $ARGUMENTS
@@ -131047,8 +131156,9 @@ function categoryResolutionError(error) {
 }
 async function resolveCategoryExecution(args, executorCtx, inheritedModel, systemDefaultModel) {
   const { client, userCategories, sisyphusJuniorModel } = executorCtx;
-  const categoryName = args.category;
   const enabledCategories = mergeCategories(userCategories);
+  const requestedCategoryName = args.category;
+  const categoryName = enabledCategories[requestedCategoryName] !== undefined ? requestedCategoryName : canonicalCategoryName(requestedCategoryName);
   const categoryExists = enabledCategories[categoryName] !== undefined;
   if (!categoryExists) {
     const allCategoryNames = Object.keys(enabledCategories).join(", ");
@@ -152711,7 +152821,7 @@ Plan Agent returns a structured work breakdown with parallel execution opportuni
 }
 function buildParallelDelegationSection(model, categories) {
   const isNonClaude = !model.toLowerCase().includes("claude");
-  const hasDelegationCategory = categories.some((category) => category.name === "deep" || category.name === "unspecified-high");
+  const hasDelegationCategory = categories.some((category) => category.name === "deep-low" || category.name === "deep-high" || category.name === "unspecified-high");
   if (!isNonClaude || !hasDelegationCategory) {
     return "";
   }
@@ -152722,7 +152832,7 @@ function buildParallelDelegationSection(model, categories) {
 **MANDATORY - for ANY implementation task:**
 
 1. **ALWAYS decompose** the task into independent work units. No exceptions. Even if the task "feels small", decompose it.
-2. **ALWAYS delegate** EACH unit to a \`deep\` or \`unspecified-high\` agent in parallel (\`run_in_background=true\`).
+2. **ALWAYS delegate** EACH unit to a \`deep-low\` or \`unspecified-high\` agent in parallel (\`run_in_background=true\`); reserve \`deep-high\` for a unit whose central decision cannot be settled from evidence.
 3. **NEVER work sequentially.** If 4 independent units exist, spawn 4 agents simultaneously. Not 1 at a time. Not 2 then 2.
 4. **NEVER implement directly** when delegation is possible. You write prompts, not code.
 
@@ -152858,7 +152968,8 @@ task(category="quick", load_skills=[], run_in_background=true, prompt="Redesign
 |---|---|
 | Visual design, UI, styling, animations, layout, design systems | \`visual-engineering\` |
 | Hard logic and architecture decisions | \`ultrabrain\` |
-| 3D graphics, computer use, browser use, backend, logic, algorithms, CAPTCHA solving, multimodal, autonomous research + end-to-end implementation | \`deep\` |
+| 3D graphics, computer use, browser use, backend, logic, algorithms, CAPTCHA solving, multimodal, autonomous research + end-to-end implementation | \`deep-low\` |
+| Any of the above whose central decision cannot be settled from evidence: a trade-off, a contract crossing a package boundary, a mechanism with no in-repo pattern, correctness argued from invariants | \`deep-high\` |
 | Single-file typo, trivial config change | \`quick\` |
 
 **When in doubt about category, it is almost never \`quick\` or \`unspecified-*\`. Match the domain.**`;
@@ -156332,7 +156443,7 @@ Don't narrate every tool call, but don't go silent for long stretches on complex
 
 ## task (delegation)
 
-\`task()\` is your primary lever. Use it to invoke specialist agents (\`subagent_type="oracle"|"metis"|"momus"|"explore"|"librarian"\`) or to delegate implementation to categories (\`category="visual-engineering"|"deep"|"ultrabrain"|"quick"|...\`). Every invocation needs \`load_skills\` (empty array \`[]\` is valid when no skills apply).
+\`task()\` is your primary lever. Use it to invoke specialist agents (\`subagent_type="oracle"|"metis"|"momus"|"explore"|"librarian"\`) or to delegate implementation to categories (\`category="visual-engineering"|"deep-low"|"deep-high"|"ultrabrain"|"quick"|...\`). Every invocation needs \`load_skills\` (empty array \`[]\` is valid when no skills apply).
 
 Parameters to always think about:
 
@@ -174068,7 +174179,7 @@ function parseWindowsProcessTable(output) {
   const entries = Array.isArray(parsed) ? parsed : parsed === undefined ? [] : [parsed];
   const processes = [];
   for (const entry of entries) {
-    if (!isRecord11(entry))
+    if (!isRecord12(entry))
       continue;
     const pid = numberField(entry, "ProcessId");
     const ppid = numberField(entry, "ParentProcessId");
@@ -174102,7 +174213,7 @@ function stringField(record, key) {
   const value = record[key];
   return typeof value === "string" ? value : undefined;
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -174206,7 +174317,7 @@ async function attestLspDaemonOwner(target, deps = {}) {
   }
 }
 function parseLspDaemonOwner(value) {
-  if (!isRecord12(value))
+  if (!isRecord13(value))
     return null;
   const pid = value["pid"];
   const nonce = value["nonce"];
@@ -174218,7 +174329,7 @@ function parseLspDaemonOwner(value) {
     return null;
   if (typeof startedAt !== "string" || startedAt.length === 0)
     return null;
-  if (!isRecord12(endpoint))
+  if (!isRecord13(endpoint))
     return null;
   const kind = endpoint["kind"];
   const path = endpoint["path"];
@@ -174270,7 +174381,7 @@ async function pingLspDaemonOwner(endpoint, authToken) {
         return finish(null);
       try {
         const response = JSON.parse(line);
-        if (!isRecord12(response) || response["id"] !== OWNER_PING_REQUEST_ID || "error" in response) {
+        if (!isRecord13(response) || response["id"] !== OWNER_PING_REQUEST_ID || "error" in response) {
           return finish(null);
         }
         finish(parseLspDaemonOwner(response["result"]));
@@ -174283,7 +174394,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 isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -174681,37 +174792,85 @@ function defaultPluginRoot() {
 // packages/telemetry-core/src/activity-state.ts
 init_atomic_write();
 init_xdg_data_dir();
-import { existsSync as existsSync111, mkdirSync as mkdirSync26, readFileSync as readFileSync76 } from "fs";
-import { basename as basename24, join as join138 } from "path";
+import { existsSync as existsSync111, mkdirSync as mkdirSync27, readFileSync as readFileSync76 } from "fs";
+import { basename as basename24, join as join139 } from "path";
+
+// packages/telemetry-core/src/day-claim.ts
+import { closeSync as closeSync6, mkdirSync as mkdirSync26, openSync as openSync6, readdirSync as readdirSync33, rmSync as rmSync6 } from "fs";
+import { join as join138 } from "path";
+var CLAIM_PREFIX = "daily-active.";
+var CLAIM_SUFFIX = ".claim";
+function getTelemetryDayClaimFilePath(stateDir, dayUTC) {
+  return join138(stateDir, `${CLAIM_PREFIX}${dayUTC}${CLAIM_SUFFIX}`);
+}
+function claimUtcDay(stateDir, dayUTC) {
+  try {
+    mkdirSync26(stateDir, { recursive: true });
+    closeSync6(openSync6(getTelemetryDayClaimFilePath(stateDir, dayUTC), "wx"));
+  } catch (error) {
+    return error.code === "EEXIST" ? "already-claimed" : "unavailable";
+  }
+  pruneSupersededClaims(stateDir, dayUTC);
+  return "claimed";
+}
+function pruneSupersededClaims(stateDir, dayUTC) {
+  const currentClaim = `${CLAIM_PREFIX}${dayUTC}${CLAIM_SUFFIX}`;
+  let entries;
+  try {
+    entries = readdirSync33(stateDir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry === currentClaim)
+      continue;
+    if (!entry.startsWith(CLAIM_PREFIX) || !entry.endsWith(CLAIM_SUFFIX))
+      continue;
+    try {
+      rmSync6(join138(stateDir, entry), { force: true });
+    } catch {}
+  }
+}
+
+// packages/telemetry-core/src/activity-state.ts
 var POSTHOG_ACTIVITY_STATE_FILE = "posthog-activity.json";
+var capturedDaysByStateDir = new Map;
 function resolveTelemetryStateDir(product, options = {}) {
   const dataDir = resolveXdgDataDir(product.cacheDirName, {
     env: options.env,
     osProvider: options.osProvider
   });
-  const xdgStateDir = options.env?.XDG_DATA_HOME === undefined ? undefined : join138(options.env.XDG_DATA_HOME, product.cacheDirName);
+  const xdgStateDir = options.env?.XDG_DATA_HOME === undefined ? undefined : join139(options.env.XDG_DATA_HOME, product.cacheDirName);
   if (dataDir === xdgStateDir || xdgStateDir === undefined && basename24(dataDir) === product.cacheDirName) {
     return dataDir;
   }
-  return join138(dataDir, product.cacheDirName);
+  return join139(dataDir, product.cacheDirName);
 }
 function getTelemetryActivityStateFilePath(stateDir) {
-  return join138(stateDir, POSTHOG_ACTIVITY_STATE_FILE);
+  return join139(stateDir, POSTHOG_ACTIVITY_STATE_FILE);
 }
 function getDailyActiveCaptureState(input) {
-  const state = readPostHogActivityState(input.stateDir, input.diagnostics);
   const dayUTC = getUtcDayString(input.now ?? new Date);
-  const captureDaily = state.lastActiveDayUTC !== dayUTC;
-  if (captureDaily) {
+  if (capturedDaysByStateDir.get(input.stateDir) === dayUTC) {
+    return { dayUTC, captureDaily: false };
+  }
+  const state = readPostHogActivityState(input.stateDir, input.diagnostics);
+  if (state.lastActiveDayUTC === dayUTC) {
+    capturedDaysByStateDir.set(input.stateDir, dayUTC);
+    return { dayUTC, captureDaily: false };
+  }
+  const claim = claimUtcDay(input.stateDir, dayUTC);
+  capturedDaysByStateDir.set(input.stateDir, dayUTC);
+  if (claim === "already-claimed") {
+    return { dayUTC, captureDaily: false };
+  }
+  if (claim === "claimed") {
     writePostHogActivityState(input.stateDir, {
       ...state,
       lastActiveDayUTC: dayUTC
     }, input.diagnostics);
   }
-  return {
-    dayUTC,
-    captureDaily
-  };
+  return { dayUTC, captureDaily: true };
 }
 function getUtcDayString(date) {
   return date.toISOString().slice(0, 10);
@@ -174744,7 +174903,7 @@ function readPostHogActivityState(stateDir, diagnostics) {
 function writePostHogActivityState(stateDir, nextState, diagnostics) {
   const stateFilePath = getTelemetryActivityStateFilePath(stateDir);
   try {
-    mkdirSync26(stateDir, { recursive: true });
+    mkdirSync27(stateDir, { recursive: true });
     writeFileAtomically(stateFilePath, `${JSON.stringify(nextState, null, 2)}
 `);
   } catch (error) {
@@ -179944,7 +180103,7 @@ var TOPLEVEL_SENTINELS = [
     field: "window_id"
   }
 ];
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value == "object" && value !== null && !Array.isArray(value);
 }
 function toRfc3339(timestamp) {
@@ -179966,7 +180125,7 @@ function relocateInto(properties, key, value) {
     properties[key] = value;
 }
 function buildV1Event(message) {
-  const sourceProperties = isRecord13(message.properties) ? message.properties : {};
+  const sourceProperties = isRecord14(message.properties) ? message.properties : {};
   const properties = {
     ...sourceProperties
   };