oh-my-opencode 3.7.1 → 3.7.2

package/dist/index.js

@@ -586,7 +586,7 @@ var require_scan = __commonJS((exports, module) => {
 
 // node_modules/picomatch/lib/parse.js
 var require_parse = __commonJS((exports, module) => {
-  var constants2 = require_constants();
+  var constants3 = require_constants();
   var utils = require_utils();
   var {
     MAX_LENGTH,
@@ -594,7 +594,7 @@ var require_parse = __commonJS((exports, module) => {
     REGEX_NON_SPECIAL_CHARS,
     REGEX_SPECIAL_CHARS_BACKREF,
     REPLACEMENTS
-  } = constants2;
+  } = constants3;
   var expandRange = (args, options) => {
     if (typeof options.expandRange === "function") {
       return options.expandRange(...args, options);
@@ -625,8 +625,8 @@ var require_parse = __commonJS((exports, module) => {
     const bos = { type: "bos", value: "", output: opts.prepend || "" };
     const tokens = [bos];
     const capture = opts.capture ? "" : "?:";
-    const PLATFORM_CHARS = constants2.globChars(opts.windows);
-    const EXTGLOB_CHARS = constants2.extglobChars(PLATFORM_CHARS);
+    const PLATFORM_CHARS = constants3.globChars(opts.windows);
+    const EXTGLOB_CHARS = constants3.extglobChars(PLATFORM_CHARS);
     const {
       DOT_LITERAL,
       PLUS_LITERAL,
@@ -1304,7 +1304,7 @@ var require_parse = __commonJS((exports, module) => {
       NO_DOTS_SLASH,
       STAR,
       START_ANCHOR
-    } = constants2.globChars(opts.windows);
+    } = constants3.globChars(opts.windows);
     const nodot = opts.dot ? NO_DOTS : NO_DOT;
     const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
     const capture = opts.capture ? "" : "?:";
@@ -1362,7 +1362,7 @@ var require_picomatch = __commonJS((exports, module) => {
   var scan = require_scan();
   var parse7 = require_parse();
   var utils = require_utils();
-  var constants2 = require_constants();
+  var constants3 = require_constants();
   var isObject3 = (val) => val && typeof val === "object" && !Array.isArray(val);
   var picomatch = (glob, options, returnState = false) => {
     if (Array.isArray(glob)) {
@@ -1493,7 +1493,7 @@ var require_picomatch = __commonJS((exports, module) => {
       return /$^/;
     }
   };
-  picomatch.constants = constants2;
+  picomatch.constants = constants3;
   module.exports = picomatch;
 });
 
@@ -5659,11 +5659,11 @@ var require_codegen = __commonJS((exports) => {
       const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`;
       return `${varKind} ${this.name}${rhs};` + _n;
     }
-    optimizeNames(names, constants18) {
+    optimizeNames(names, constants19) {
       if (!names[this.name.str])
         return;
       if (this.rhs)
-        this.rhs = optimizeExpr(this.rhs, names, constants18);
+        this.rhs = optimizeExpr(this.rhs, names, constants19);
       return this;
     }
     get names() {
@@ -5681,10 +5681,10 @@ var require_codegen = __commonJS((exports) => {
     render({ _n }) {
       return `${this.lhs} = ${this.rhs};` + _n;
     }
-    optimizeNames(names, constants18) {
+    optimizeNames(names, constants19) {
       if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
         return;
-      this.rhs = optimizeExpr(this.rhs, names, constants18);
+      this.rhs = optimizeExpr(this.rhs, names, constants19);
       return this;
     }
     get names() {
@@ -5750,8 +5750,8 @@ var require_codegen = __commonJS((exports) => {
     optimizeNodes() {
       return `${this.code}` ? this : undefined;
     }
-    optimizeNames(names, constants18) {
-      this.code = optimizeExpr(this.code, names, constants18);
+    optimizeNames(names, constants19) {
+      this.code = optimizeExpr(this.code, names, constants19);
       return this;
     }
     get names() {
@@ -5781,12 +5781,12 @@ var require_codegen = __commonJS((exports) => {
       }
       return nodes.length > 0 ? this : undefined;
     }
-    optimizeNames(names, constants18) {
+    optimizeNames(names, constants19) {
       const { nodes } = this;
       let i2 = nodes.length;
       while (i2--) {
         const n = nodes[i2];
-        if (n.optimizeNames(names, constants18))
+        if (n.optimizeNames(names, constants19))
           continue;
         subtractNames(names, n.names);
         nodes.splice(i2, 1);
@@ -5843,12 +5843,12 @@ var require_codegen = __commonJS((exports) => {
         return;
       return this;
     }
-    optimizeNames(names, constants18) {
+    optimizeNames(names, constants19) {
       var _a;
-      this.else = (_a = this.else) === null || _a === undefined ? undefined : _a.optimizeNames(names, constants18);
-      if (!(super.optimizeNames(names, constants18) || this.else))
+      this.else = (_a = this.else) === null || _a === undefined ? undefined : _a.optimizeNames(names, constants19);
+      if (!(super.optimizeNames(names, constants19) || this.else))
         return;
-      this.condition = optimizeExpr(this.condition, names, constants18);
+      this.condition = optimizeExpr(this.condition, names, constants19);
       return this;
     }
     get names() {
@@ -5873,10 +5873,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.iteration})` + super.render(opts);
     }
-    optimizeNames(names, constants18) {
-      if (!super.optimizeNames(names, constants18))
+    optimizeNames(names, constants19) {
+      if (!super.optimizeNames(names, constants19))
         return;
-      this.iteration = optimizeExpr(this.iteration, names, constants18);
+      this.iteration = optimizeExpr(this.iteration, names, constants19);
       return this;
     }
     get names() {
@@ -5914,10 +5914,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
     }
-    optimizeNames(names, constants18) {
-      if (!super.optimizeNames(names, constants18))
+    optimizeNames(names, constants19) {
+      if (!super.optimizeNames(names, constants19))
         return;
-      this.iterable = optimizeExpr(this.iterable, names, constants18);
+      this.iterable = optimizeExpr(this.iterable, names, constants19);
       return this;
     }
     get names() {
@@ -5962,11 +5962,11 @@ var require_codegen = __commonJS((exports) => {
       (_b = this.finally) === null || _b === undefined || _b.optimizeNodes();
       return this;
     }
-    optimizeNames(names, constants18) {
+    optimizeNames(names, constants19) {
       var _a, _b;
-      super.optimizeNames(names, constants18);
-      (_a = this.catch) === null || _a === undefined || _a.optimizeNames(names, constants18);
-      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants18);
+      super.optimizeNames(names, constants19);
+      (_a = this.catch) === null || _a === undefined || _a.optimizeNames(names, constants19);
+      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants19);
       return this;
     }
     get names() {
@@ -6240,7 +6240,7 @@ var require_codegen = __commonJS((exports) => {
   function addExprNames(names, from) {
     return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
   }
-  function optimizeExpr(expr, names, constants18) {
+  function optimizeExpr(expr, names, constants19) {
     if (expr instanceof code_1.Name)
       return replaceName(expr);
     if (!canOptimize(expr))
@@ -6255,14 +6255,14 @@ var require_codegen = __commonJS((exports) => {
       return items;
     }, []));
     function replaceName(n) {
-      const c = constants18[n.str];
+      const c = constants19[n.str];
       if (c === undefined || names[n.str] !== 1)
         return n;
       delete names[n.str];
       return c;
     }
     function canOptimize(e) {
-      return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants18[c.str] !== undefined);
+      return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants19[c.str] !== undefined);
     }
   }
   function subtractNames(names, from) {
@@ -6709,37 +6709,37 @@ var require_dataType = __commonJS((exports) => {
     DataType2[DataType2["Wrong"] = 1] = "Wrong";
   })(DataType || (exports.DataType = DataType = {}));
   function getSchemaTypes(schema2) {
-    const types20 = getJSONTypes(schema2.type);
-    const hasNull = types20.includes("null");
+    const types21 = getJSONTypes(schema2.type);
+    const hasNull = types21.includes("null");
     if (hasNull) {
       if (schema2.nullable === false)
         throw new Error("type: null contradicts nullable: false");
     } else {
-      if (!types20.length && schema2.nullable !== undefined) {
+      if (!types21.length && schema2.nullable !== undefined) {
         throw new Error('"nullable" cannot be used without "type"');
       }
       if (schema2.nullable === true)
-        types20.push("null");
+        types21.push("null");
     }
-    return types20;
+    return types21;
   }
   exports.getSchemaTypes = getSchemaTypes;
   function getJSONTypes(ts) {
-    const types20 = Array.isArray(ts) ? ts : ts ? [ts] : [];
-    if (types20.every(rules_1.isJSONType))
-      return types20;
-    throw new Error("type must be JSONType or JSONType[]: " + types20.join(","));
+    const types21 = Array.isArray(ts) ? ts : ts ? [ts] : [];
+    if (types21.every(rules_1.isJSONType))
+      return types21;
+    throw new Error("type must be JSONType or JSONType[]: " + types21.join(","));
   }
   exports.getJSONTypes = getJSONTypes;
-  function coerceAndCheckDataType(it, types20) {
+  function coerceAndCheckDataType(it, types21) {
     const { gen, data, opts } = it;
-    const coerceTo = coerceToTypes(types20, opts.coerceTypes);
-    const checkTypes = types20.length > 0 && !(coerceTo.length === 0 && types20.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types20[0]));
+    const coerceTo = coerceToTypes(types21, opts.coerceTypes);
+    const checkTypes = types21.length > 0 && !(coerceTo.length === 0 && types21.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types21[0]));
     if (checkTypes) {
-      const wrongType = checkDataTypes(types20, data, opts.strictNumbers, DataType.Wrong);
+      const wrongType = checkDataTypes(types21, data, opts.strictNumbers, DataType.Wrong);
       gen.if(wrongType, () => {
         if (coerceTo.length)
-          coerceData(it, types20, coerceTo);
+          coerceData(it, types21, coerceTo);
         else
           reportTypeError(it);
       });
@@ -6748,15 +6748,15 @@ var require_dataType = __commonJS((exports) => {
   }
   exports.coerceAndCheckDataType = coerceAndCheckDataType;
   var COERCIBLE = new Set(["string", "number", "integer", "boolean", "null"]);
-  function coerceToTypes(types20, coerceTypes) {
-    return coerceTypes ? types20.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
+  function coerceToTypes(types21, coerceTypes) {
+    return coerceTypes ? types21.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
   }
-  function coerceData(it, types20, coerceTo) {
+  function coerceData(it, types21, coerceTo) {
     const { gen, data, opts } = it;
     const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
     const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
     if (opts.coerceTypes === "array") {
-      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types20, data, opts.strictNumbers), () => gen.assign(coerced, data)));
+      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types21, data, opts.strictNumbers), () => gen.assign(coerced, data)));
     }
     gen.if((0, codegen_1._)`${coerced} !== undefined`);
     for (const t of coerceTo) {
@@ -6832,19 +6832,19 @@ var require_dataType = __commonJS((exports) => {
       return checkDataType(dataTypes[0], data, strictNums, correct);
     }
     let cond;
-    const types20 = (0, util_1.toHash)(dataTypes);
-    if (types20.array && types20.object) {
+    const types21 = (0, util_1.toHash)(dataTypes);
+    if (types21.array && types21.object) {
       const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
-      cond = types20.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
-      delete types20.null;
-      delete types20.array;
-      delete types20.object;
+      cond = types21.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
+      delete types21.null;
+      delete types21.array;
+      delete types21.object;
     } else {
       cond = codegen_1.nil;
     }
-    if (types20.number)
-      delete types20.integer;
-    for (const t in types20)
+    if (types21.number)
+      delete types21.integer;
+    for (const t in types21)
       cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
     return cond;
   }
@@ -7632,9 +7632,9 @@ var require_validate = __commonJS((exports) => {
   function typeAndKeywords(it, errsCount) {
     if (it.opts.jtd)
       return schemaKeywords(it, [], false, errsCount);
-    const types20 = (0, dataType_1.getSchemaTypes)(it.schema);
-    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types20);
-    schemaKeywords(it, types20, !checkedTypes, errsCount);
+    const types21 = (0, dataType_1.getSchemaTypes)(it.schema);
+    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types21);
+    schemaKeywords(it, types21, !checkedTypes, errsCount);
   }
   function checkRefsAndKeywords(it) {
     const { schema: schema2, errSchemaPath, opts, self } = it;
@@ -7684,7 +7684,7 @@ var require_validate = __commonJS((exports) => {
     if (items instanceof codegen_1.Name)
       gen.assign((0, codegen_1._)`${evaluated}.items`, items);
   }
-  function schemaKeywords(it, types20, typeErrors, errsCount) {
+  function schemaKeywords(it, types21, typeErrors, errsCount) {
     const { gen, schema: schema2, data, allErrors, opts, self } = it;
     const { RULES } = self;
     if (schema2.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema2, RULES))) {
@@ -7692,7 +7692,7 @@ var require_validate = __commonJS((exports) => {
       return;
     }
     if (!opts.jtd)
-      checkStrictTypes(it, types20);
+      checkStrictTypes(it, types21);
     gen.block(() => {
       for (const group of RULES.rules)
         groupKeywords(group);
@@ -7704,7 +7704,7 @@ var require_validate = __commonJS((exports) => {
       if (group.type) {
         gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
         iterateKeywords(it, group);
-        if (types20.length === 1 && types20[0] === group.type && typeErrors) {
+        if (types21.length === 1 && types21[0] === group.type && typeErrors) {
           gen.else();
           (0, dataType_2.reportTypeError)(it);
         }
@@ -7728,27 +7728,27 @@ var require_validate = __commonJS((exports) => {
       }
     });
   }
-  function checkStrictTypes(it, types20) {
+  function checkStrictTypes(it, types21) {
     if (it.schemaEnv.meta || !it.opts.strictTypes)
       return;
-    checkContextTypes(it, types20);
+    checkContextTypes(it, types21);
     if (!it.opts.allowUnionTypes)
-      checkMultipleTypes(it, types20);
+      checkMultipleTypes(it, types21);
     checkKeywordTypes(it, it.dataTypes);
   }
-  function checkContextTypes(it, types20) {
-    if (!types20.length)
+  function checkContextTypes(it, types21) {
+    if (!types21.length)
       return;
     if (!it.dataTypes.length) {
-      it.dataTypes = types20;
+      it.dataTypes = types21;
       return;
     }
-    types20.forEach((t) => {
+    types21.forEach((t) => {
       if (!includesType(it.dataTypes, t)) {
         strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
       }
     });
-    narrowSchemaTypes(it, types20);
+    narrowSchemaTypes(it, types21);
   }
   function checkMultipleTypes(it, ts) {
     if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
@@ -12242,7 +12242,56 @@ var ABORT_WINDOW_MS = 3000;
 var CONTINUATION_COOLDOWN_MS = 30000;
 var MAX_CONSECUTIVE_FAILURES = 5;
 var FAILURE_RESET_WINDOW_MS = 5 * 60 * 1000;
-
+// src/features/run-continuation-state/constants.ts
+var CONTINUATION_MARKER_DIR = ".sisyphus/run-continuation";
+// src/features/run-continuation-state/storage.ts
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+function getMarkerPath(directory, sessionID) {
+  return join2(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+}
+function readContinuationMarker(directory, sessionID) {
+  const markerPath = getMarkerPath(directory, sessionID);
+  if (!existsSync(markerPath))
+    return null;
+  try {
+    const raw = readFileSync(markerPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function setContinuationMarkerSource(directory, sessionID, source, state, reason) {
+  const now = new Date().toISOString();
+  const existing = readContinuationMarker(directory, sessionID);
+  const next = {
+    sessionID,
+    updatedAt: now,
+    sources: {
+      ...existing?.sources ?? {},
+      [source]: {
+        state,
+        ...reason ? { reason } : {},
+        updatedAt: now
+      }
+    }
+  };
+  const markerPath = getMarkerPath(directory, sessionID);
+  mkdirSync(join2(directory, CONTINUATION_MARKER_DIR), { recursive: true });
+  writeFileSync(markerPath, JSON.stringify(next, null, 2), "utf-8");
+  return next;
+}
+function clearContinuationMarker(directory, sessionID) {
+  const markerPath = getMarkerPath(directory, sessionID);
+  if (!existsSync(markerPath))
+    return;
+  try {
+    rmSync(markerPath);
+  } catch {}
+}
 // src/hooks/todo-continuation-enforcer/handler.ts
 init_logger();
 
@@ -14896,7 +14945,7 @@ var load = loader.load;
 var loadAll = loader.loadAll;
 var dump = dumper.dump;
 var YAMLException = exception;
-var types = {
+var types2 = {
   binary,
   float,
   map,
@@ -14925,7 +14974,7 @@ var jsYaml = {
   loadAll,
   dump,
   YAMLException,
-  types,
+  types: types2,
   safeLoad,
   safeLoadAll,
   safeDump
@@ -14958,15 +15007,15 @@ function getHomeDirectory() {
 }
 
 // src/shared/command-executor/shell-path.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 var DEFAULT_ZSH_PATHS = ["/bin/zsh", "/usr/bin/zsh", "/usr/local/bin/zsh"];
 var DEFAULT_BASH_PATHS = ["/bin/bash", "/usr/bin/bash", "/usr/local/bin/bash"];
 function findShellPath(defaultPaths, customPath) {
-  if (customPath && existsSync(customPath)) {
+  if (customPath && existsSync2(customPath)) {
     return customPath;
   }
   for (const path2 of defaultPaths) {
-    if (existsSync(path2)) {
+    if (existsSync2(path2)) {
       return path2;
     }
   }
@@ -15094,8 +15143,8 @@ async function resolveCommandsInText(text, depth = 0, maxDepth = 3) {
   return resolved;
 }
 // src/shared/file-reference-resolver.ts
-import { existsSync as existsSync2, readFileSync, statSync } from "fs";
-import { join as join2, isAbsolute } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join3, isAbsolute } from "path";
 var FILE_REFERENCE_PATTERN = /@([^\s@]+)/g;
 function findFileReferences(text) {
   const matches = [];
@@ -15115,17 +15164,17 @@ function resolveFilePath(filePath, cwd) {
   if (isAbsolute(filePath)) {
     return filePath;
   }
-  return join2(cwd, filePath);
+  return join3(cwd, filePath);
 }
 function readFileContent(resolvedPath) {
-  if (!existsSync2(resolvedPath)) {
+  if (!existsSync3(resolvedPath)) {
     return `[file not found: ${resolvedPath}]`;
   }
   const stat = statSync(resolvedPath);
   if (stat.isDirectory()) {
     return `[cannot read directory: ${resolvedPath}]`;
   }
-  const content = readFileSync(resolvedPath, "utf-8");
+  const content = readFileSync2(resolvedPath, "utf-8");
   return content;
 }
 async function resolveFileReferencesInText(text, cwd = process.cwd(), depth = 0, maxDepth = 3) {
@@ -15477,16 +15526,16 @@ function addConfigLoadError(error) {
 }
 // src/shared/claude-config-dir.ts
 import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function getClaudeConfigDir() {
   const envConfigDir = process.env.CLAUDE_CONFIG_DIR;
   if (envConfigDir) {
     return envConfigDir;
   }
-  return join4(homedir3(), ".claude");
+  return join5(homedir3(), ".claude");
 }
 // src/shared/jsonc-parser.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 
 // node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -16360,10 +16409,10 @@ function parseJsoncSafe(content) {
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
-  if (existsSync3(jsoncPath)) {
+  if (existsSync4(jsoncPath)) {
     return { format: "jsonc", path: jsoncPath };
   }
-  if (existsSync3(jsonPath)) {
+  if (existsSync4(jsonPath)) {
     return { format: "json", path: jsonPath };
   }
   return { format: "none", path: jsonPath };
@@ -16578,9 +16627,9 @@ function migrateConfigFile(configPath, rawConfig) {
   return needsWrite;
 }
 // src/shared/opencode-config-dir.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join5, resolve } from "path";
+import { join as join6, resolve } from "path";
 var TAURI_APP_IDENTIFIER = "ai.opencode.desktop";
 var TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
 function isDevBuild(version) {
@@ -16592,15 +16641,15 @@ function getTauriConfigDir(identifier) {
   const platform = process.platform;
   switch (platform) {
     case "darwin":
-      return join5(homedir4(), "Library", "Application Support", identifier);
+      return join6(homedir4(), "Library", "Application Support", identifier);
     case "win32": {
-      const appData = process.env.APPDATA || join5(homedir4(), "AppData", "Roaming");
-      return join5(appData, identifier);
+      const appData = process.env.APPDATA || join6(homedir4(), "AppData", "Roaming");
+      return join6(appData, identifier);
     }
     case "linux":
     default: {
-      const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir4(), ".config");
-      return join5(xdgConfig, identifier);
+      const xdgConfig = process.env.XDG_CONFIG_HOME || join6(homedir4(), ".config");
+      return join6(xdgConfig, identifier);
     }
   }
 }
@@ -16610,21 +16659,21 @@ function getCliConfigDir() {
     return resolve(envConfigDir);
   }
   if (process.platform === "win32") {
-    const crossPlatformDir = join5(homedir4(), ".config", "opencode");
-    const crossPlatformConfig = join5(crossPlatformDir, "opencode.json");
-    if (existsSync4(crossPlatformConfig)) {
+    const crossPlatformDir = join6(homedir4(), ".config", "opencode");
+    const crossPlatformConfig = join6(crossPlatformDir, "opencode.json");
+    if (existsSync5(crossPlatformConfig)) {
       return crossPlatformDir;
     }
-    const appData = process.env.APPDATA || join5(homedir4(), "AppData", "Roaming");
-    const appdataDir = join5(appData, "opencode");
-    const appdataConfig = join5(appdataDir, "opencode.json");
-    if (existsSync4(appdataConfig)) {
+    const appData = process.env.APPDATA || join6(homedir4(), "AppData", "Roaming");
+    const appdataDir = join6(appData, "opencode");
+    const appdataConfig = join6(appdataDir, "opencode.json");
+    if (existsSync5(appdataConfig)) {
       return appdataDir;
     }
     return crossPlatformDir;
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir4(), ".config");
-  return join5(xdgConfig, "opencode");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join6(homedir4(), ".config");
+  return join6(xdgConfig, "opencode");
 }
 function getOpenCodeConfigDir(options) {
   const { binary: binary2, version, checkExisting = true } = options;
@@ -16635,9 +16684,9 @@ function getOpenCodeConfigDir(options) {
   const tauriDir = getTauriConfigDir(identifier);
   if (checkExisting) {
     const legacyDir = getCliConfigDir();
-    const legacyConfig = join5(legacyDir, "opencode.json");
-    const legacyConfigC = join5(legacyDir, "opencode.jsonc");
-    if (existsSync4(legacyConfig) || existsSync4(legacyConfigC)) {
+    const legacyConfig = join6(legacyDir, "opencode.json");
+    const legacyConfigC = join6(legacyDir, "opencode.jsonc");
+    if (existsSync5(legacyConfig) || existsSync5(legacyConfigC)) {
       return legacyDir;
     }
   }
@@ -16647,10 +16696,10 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir(options);
   return {
     configDir,
-    configJson: join5(configDir, "opencode.json"),
-    configJsonc: join5(configDir, "opencode.jsonc"),
-    packageJson: join5(configDir, "package.json"),
-    omoConfig: join5(configDir, "oh-my-opencode.json")
+    configJson: join6(configDir, "opencode.json"),
+    configJsonc: join6(configDir, "opencode.jsonc"),
+    packageJson: join6(configDir, "package.json"),
+    omoConfig: join6(configDir, "oh-my-opencode.json")
   };
 }
 // src/shared/opencode-version.ts
@@ -16702,8 +16751,8 @@ function isOpenCodeVersionAtLeast(version) {
   return compareVersions(current, version) >= 0;
 }
 // src/shared/opencode-storage-detection.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join7 } from "path";
 var NOT_CACHED2 = Symbol("NOT_CACHED");
 var FALSE_PENDING_RETRY = Symbol("FALSE_PENDING_RETRY");
 var cachedResult = NOT_CACHED2;
@@ -16714,8 +16763,8 @@ function isSqliteBackend() {
     return false;
   const check = () => {
     const versionOk = isOpenCodeVersionAtLeast(OPENCODE_SQLITE_VERSION);
-    const dbPath = join6(getDataDir(), "opencode", "opencode.db");
-    return versionOk && existsSync5(dbPath);
+    const dbPath = join7(getDataDir(), "opencode", "opencode.db");
+    return versionOk && existsSync6(dbPath);
   };
   if (cachedResult === FALSE_PENDING_RETRY) {
     const result2 = check();
@@ -16933,16 +16982,16 @@ async function extractZip(archivePath, destDir) {
   }
 }
 // src/shared/binary-downloader.ts
-import { chmodSync, existsSync as existsSync7, mkdirSync, unlinkSync } from "fs";
+import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync2, unlinkSync } from "fs";
 import * as path4 from "path";
 var {spawn: spawn3 } = globalThis.Bun;
 function getCachedBinaryPath(cacheDir, binaryName) {
   const binaryPath = path4.join(cacheDir, binaryName);
-  return existsSync7(binaryPath) ? binaryPath : null;
+  return existsSync8(binaryPath) ? binaryPath : null;
 }
 function ensureCacheDir(cacheDir) {
-  if (!existsSync7(cacheDir)) {
-    mkdirSync(cacheDir, { recursive: true });
+  if (!existsSync8(cacheDir)) {
+    mkdirSync2(cacheDir, { recursive: true });
   }
 }
 async function downloadArchive(downloadUrl, archivePath) {
@@ -16970,12 +17019,12 @@ async function extractZipArchive(archivePath, destDir) {
   await extractZip(archivePath, destDir);
 }
 function cleanupArchive(archivePath) {
-  if (existsSync7(archivePath)) {
+  if (existsSync8(archivePath)) {
     unlinkSync(archivePath);
   }
 }
 function ensureExecutable(binaryPath) {
-  if (process.platform !== "win32" && existsSync7(binaryPath)) {
+  if (process.platform !== "win32" && existsSync8(binaryPath)) {
     chmodSync(binaryPath, 493);
   }
 }
@@ -17314,27 +17363,27 @@ init_logger();
 
 // src/shared/connected-providers-cache.ts
 init_logger();
-import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join10 } from "path";
 var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json";
 var PROVIDER_MODELS_CACHE_FILE = "provider-models.json";
 function getCacheFilePath(filename) {
-  return join9(getOmoOpenCodeCacheDir(), filename);
+  return join10(getOmoOpenCodeCacheDir(), filename);
 }
 function ensureCacheDir2() {
   const cacheDir = getOmoOpenCodeCacheDir();
-  if (!existsSync8(cacheDir)) {
-    mkdirSync2(cacheDir, { recursive: true });
+  if (!existsSync9(cacheDir)) {
+    mkdirSync3(cacheDir, { recursive: true });
   }
 }
 function readConnectedProvidersCache() {
   const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
-  if (!existsSync8(cacheFile)) {
+  if (!existsSync9(cacheFile)) {
     log("[connected-providers-cache] Cache file not found", { cacheFile });
     return null;
   }
   try {
-    const content = readFileSync4(cacheFile, "utf-8");
+    const content = readFileSync5(cacheFile, "utf-8");
     const data = JSON.parse(content);
     log("[connected-providers-cache] Read cache", { count: data.connected.length, updatedAt: data.updatedAt });
     return data.connected;
@@ -17345,7 +17394,7 @@ function readConnectedProvidersCache() {
 }
 function hasConnectedProvidersCache() {
   const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
-  return existsSync8(cacheFile);
+  return existsSync9(cacheFile);
 }
 function writeConnectedProvidersCache(connected) {
   ensureCacheDir2();
@@ -17355,7 +17404,7 @@ function writeConnectedProvidersCache(connected) {
     updatedAt: new Date().toISOString()
   };
   try {
-    writeFileSync2(cacheFile, JSON.stringify(data, null, 2));
+    writeFileSync3(cacheFile, JSON.stringify(data, null, 2));
     log("[connected-providers-cache] Cache written", { count: connected.length });
   } catch (err) {
     log("[connected-providers-cache] Error writing cache", { error: String(err) });
@@ -17363,12 +17412,12 @@ function writeConnectedProvidersCache(connected) {
 }
 function readProviderModelsCache() {
   const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
-  if (!existsSync8(cacheFile)) {
+  if (!existsSync9(cacheFile)) {
     log("[connected-providers-cache] Provider-models cache file not found", { cacheFile });
     return null;
   }
   try {
-    const content = readFileSync4(cacheFile, "utf-8");
+    const content = readFileSync5(cacheFile, "utf-8");
     const data = JSON.parse(content);
     log("[connected-providers-cache] Read provider-models cache", {
       providerCount: Object.keys(data.models).length,
@@ -17382,7 +17431,7 @@ function readProviderModelsCache() {
 }
 function hasProviderModelsCache() {
   const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
-  return existsSync8(cacheFile);
+  return existsSync9(cacheFile);
 }
 function writeProviderModelsCache(data) {
   ensureCacheDir2();
@@ -17392,7 +17441,7 @@ function writeProviderModelsCache(data) {
     updatedAt: new Date().toISOString()
   };
   try {
-    writeFileSync2(cacheFile, JSON.stringify(cacheData, null, 2));
+    writeFileSync3(cacheFile, JSON.stringify(cacheData, null, 2));
     log("[connected-providers-cache] Provider-models cache written", {
       providerCount: Object.keys(data.models).length
     });
@@ -17435,8 +17484,8 @@ async function updateConnectedProvidersCache(client) {
 
 // src/shared/model-availability.ts
 init_logger();
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
+import { join as join11 } from "path";
 function normalizeModelName(name) {
   return name.toLowerCase().replace(/claude-(opus|sonnet|haiku)-(\d+)[.-](\d+)/g, "claude-$1-$2.$3");
 }
@@ -17572,12 +17621,12 @@ async function fetchAvailableModels(client, options) {
     }
   }
   log("[fetchAvailableModels] provider-models cache not found, falling back to models.json");
-  const cacheFile = join10(getOpenCodeCacheDir(), "models.json");
-  if (!existsSync9(cacheFile)) {
+  const cacheFile = join11(getOpenCodeCacheDir(), "models.json");
+  if (!existsSync10(cacheFile)) {
     log("[fetchAvailableModels] models.json cache file not found, falling back to client");
   } else {
     try {
-      const content = readFileSync5(cacheFile, "utf-8");
+      const content = readFileSync6(cacheFile, "utf-8");
       const data = JSON.parse(content);
       const providerIds = Object.keys(data);
       log("[fetchAvailableModels] providers found in models.json", { count: providerIds.length, providers: providerIds.slice(0, 10) });
@@ -17629,8 +17678,8 @@ function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
   }
-  const cacheFile = join10(getOpenCodeCacheDir(), "models.json");
-  return existsSync9(cacheFile);
+  const cacheFile = join11(getOpenCodeCacheDir(), "models.json");
+  return existsSync10(cacheFile);
 }
 
 // src/shared/model-resolution-pipeline.ts
@@ -17906,8 +17955,8 @@ function isAnyProviderConnected(providers, availableModels) {
   return false;
 }
 // src/features/hook-message-injector/injector.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync6, readdirSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync7, readdirSync, writeFileSync as writeFileSync4 } from "fs";
+import { join as join12 } from "path";
 init_logger();
 function convertSDKMessageToStoredMessage(msg) {
   const info = msg.info;
@@ -17975,7 +18024,7 @@ function findNearestMessageWithFields(messageDir) {
     const files = readdirSync(messageDir).filter((f) => f.endsWith(".json")).sort().reverse();
     for (const file of files) {
       try {
-        const content = readFileSync6(join11(messageDir, file), "utf-8");
+        const content = readFileSync7(join12(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.agent && msg.model?.providerID && msg.model?.modelID) {
           return msg;
@@ -17986,7 +18035,7 @@ function findNearestMessageWithFields(messageDir) {
     }
     for (const file of files) {
       try {
-        const content = readFileSync6(join11(messageDir, file), "utf-8");
+        const content = readFileSync7(join12(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.agent || msg.model?.providerID && msg.model?.modelID) {
           return msg;
@@ -18008,7 +18057,7 @@ function findFirstMessageWithAgent(messageDir) {
     const files = readdirSync(messageDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of files) {
       try {
-        const content = readFileSync6(join11(messageDir, file), "utf-8");
+        const content = readFileSync7(join12(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.agent) {
           return msg.agent;
@@ -18033,15 +18082,15 @@ async function resolveMessageContext(sessionID, client, messageDir) {
   return { prevMessage, firstMessageAgent };
 }
 // src/shared/opencode-message-dir.ts
-import { existsSync as existsSync11, readdirSync as readdirSync2 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync2 } from "fs";
+import { join as join14 } from "path";
 
 // src/shared/opencode-storage-paths.ts
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var OPENCODE_STORAGE = getOpenCodeStorageDir();
-var MESSAGE_STORAGE = join12(OPENCODE_STORAGE, "message");
-var PART_STORAGE = join12(OPENCODE_STORAGE, "part");
-var SESSION_STORAGE = join12(OPENCODE_STORAGE, "session");
+var MESSAGE_STORAGE = join13(OPENCODE_STORAGE, "message");
+var PART_STORAGE = join13(OPENCODE_STORAGE, "part");
+var SESSION_STORAGE = join13(OPENCODE_STORAGE, "session");
 
 // src/shared/opencode-message-dir.ts
 init_logger();
@@ -18052,16 +18101,16 @@ function getMessageDir(sessionID) {
     return null;
   if (isSqliteBackend())
     return null;
-  if (!existsSync11(MESSAGE_STORAGE))
+  if (!existsSync12(MESSAGE_STORAGE))
     return null;
-  const directPath = join13(MESSAGE_STORAGE, sessionID);
-  if (existsSync11(directPath)) {
+  const directPath = join14(MESSAGE_STORAGE, sessionID);
+  if (existsSync12(directPath)) {
     return directPath;
   }
   try {
     for (const dir of readdirSync2(MESSAGE_STORAGE)) {
-      const sessionPath = join13(MESSAGE_STORAGE, dir, sessionID);
-      if (existsSync11(sessionPath)) {
+      const sessionPath = join14(MESSAGE_STORAGE, dir, sessionID);
+      if (existsSync12(sessionPath)) {
         return sessionPath;
       }
     }
@@ -18774,6 +18823,31 @@ async function deletePart(client, sessionID, messageID, partID) {
     return false;
   }
 }
+// src/shared/port-utils.ts
+var DEFAULT_SERVER_PORT = 4096;
+var MAX_PORT_ATTEMPTS = 20;
+async function isPortAvailable(port, hostname = "127.0.0.1") {
+  try {
+    const server = Bun.serve({
+      port,
+      hostname,
+      fetch: () => new Response
+    });
+    server.stop(true);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findAvailablePort(startPort = DEFAULT_SERVER_PORT, hostname = "127.0.0.1") {
+  for (let attempt = 0;attempt < MAX_PORT_ATTEMPTS; attempt++) {
+    const port = startPort + attempt;
+    if (await isPortAvailable(port, hostname)) {
+      return port;
+    }
+  }
+  throw new Error(`No available port found in range ${startPort}-${startPort + MAX_PORT_ATTEMPTS - 1}`);
+}
 // src/shared/git-worktree/parse-status-porcelain-line.ts
 function toGitFileStatus(statusToken) {
   if (statusToken === "A" || statusToken === "??")
@@ -18832,8 +18906,8 @@ function parseGitDiffNumstat(output, statusMap) {
 }
 // src/shared/git-worktree/collect-git-diff-stats.ts
 import { execFileSync } from "child_process";
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join15 } from "path";
 function collectGitDiffStats(directory) {
   try {
     const diffOutput = execFileSync("git", ["diff", "--numstat", "HEAD"], {
@@ -18857,7 +18931,7 @@ function collectGitDiffStats(directory) {
     const untrackedNumstat = untrackedOutput ? untrackedOutput.split(`
 `).filter(Boolean).map((filePath) => {
       try {
-        const content = readFileSync7(join14(directory, filePath), "utf-8");
+        const content = readFileSync8(join15(directory, filePath), "utf-8");
         const lineCount = content.split(`
 `).length - (content.endsWith(`
 `) ? 1 : 0);
@@ -19362,6 +19436,12 @@ function createTodoContinuationHandler(args) {
       });
       return;
     }
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info;
+      if (sessionInfo?.id) {
+        clearContinuationMarker(ctx.directory, sessionInfo.id);
+      }
+    }
     handleNonIdleEvent({
       eventType: event.type,
       properties: props,
@@ -19999,20 +20079,20 @@ function generatePartId() {
   return `prt_${timestamp2}${random}`;
 }
 // src/hooks/session-recovery/storage/messages-reader.ts
-import { existsSync as existsSync12, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "fs";
+import { join as join16 } from "path";
 function readMessages(sessionID) {
   if (isSqliteBackend())
     return [];
   const messageDir = getMessageDir(sessionID);
-  if (!messageDir || !existsSync12(messageDir))
+  if (!messageDir || !existsSync13(messageDir))
     return [];
   const messages = [];
   for (const file of readdirSync3(messageDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync8(join15(messageDir, file), "utf-8");
+      const content = readFileSync9(join16(messageDir, file), "utf-8");
       messages.push(JSON.parse(content));
     } catch {
       continue;
@@ -20027,8 +20107,8 @@ function readMessages(sessionID) {
   });
 }
 // src/hooks/session-recovery/storage/parts-reader.ts
-import { existsSync as existsSync13, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync10 } from "fs";
+import { join as join17 } from "path";
 
 // src/hooks/session-recovery/constants.ts
 var THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"]);
@@ -20039,15 +20119,15 @@ var CONTENT_TYPES = new Set(["text", "tool", "tool_use", "tool_result"]);
 function readParts(messageID) {
   if (isSqliteBackend())
     return [];
-  const partDir = join16(PART_STORAGE, messageID);
-  if (!existsSync13(partDir))
+  const partDir = join17(PART_STORAGE, messageID);
+  if (!existsSync14(partDir))
     return [];
   const parts = [];
   for (const file of readdirSync4(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync9(join16(partDir, file), "utf-8");
+      const content = readFileSync10(join17(partDir, file), "utf-8");
       parts.push(JSON.parse(content));
     } catch {
       continue;
@@ -20078,16 +20158,16 @@ function messageHasContent(messageID) {
   return parts.some(hasContent);
 }
 // src/hooks/session-recovery/storage/text-part-injector.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join18 } from "path";
 function injectTextPart(sessionID, messageID, text) {
   if (isSqliteBackend()) {
     log("[session-recovery] Disabled on SQLite backend: injectTextPart (use async variant)");
     return false;
   }
-  const partDir = join17(PART_STORAGE, messageID);
-  if (!existsSync14(partDir)) {
-    mkdirSync4(partDir, { recursive: true });
+  const partDir = join18(PART_STORAGE, messageID);
+  if (!existsSync15(partDir)) {
+    mkdirSync5(partDir, { recursive: true });
   }
   const partId = generatePartId();
   const part = {
@@ -20099,7 +20179,7 @@ function injectTextPart(sessionID, messageID, text) {
     synthetic: true
   };
   try {
-    writeFileSync4(join17(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    writeFileSync5(join18(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
     return true;
   } catch {
     return false;
@@ -20156,30 +20236,30 @@ function findEmptyMessageByIndex(sessionID, targetIndex) {
   return null;
 }
 // src/hooks/session-recovery/storage/empty-text.ts
-import { existsSync as existsSync15, readdirSync as readdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
+import { join as join19 } from "path";
 function replaceEmptyTextParts(messageID, replacementText) {
   if (isSqliteBackend()) {
     log("[session-recovery] Disabled on SQLite backend: replaceEmptyTextParts (use async variant)");
     return false;
   }
-  const partDir = join18(PART_STORAGE, messageID);
-  if (!existsSync15(partDir))
+  const partDir = join19(PART_STORAGE, messageID);
+  if (!existsSync16(partDir))
     return false;
   let anyReplaced = false;
   for (const file of readdirSync5(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const filePath = join18(partDir, file);
-      const content = readFileSync10(filePath, "utf-8");
+      const filePath = join19(partDir, file);
+      const content = readFileSync11(filePath, "utf-8");
       const part = JSON.parse(content);
       if (part.type === "text") {
         const textPart = part;
         if (!textPart.text?.trim()) {
           textPart.text = replacementText;
           textPart.synthetic = true;
-          writeFileSync5(filePath, JSON.stringify(textPart, null, 2));
+          writeFileSync6(filePath, JSON.stringify(textPart, null, 2));
           anyReplaced = true;
         }
       }
@@ -20264,8 +20344,8 @@ function findMessageByIndexNeedingThinking(sessionID, targetIndex) {
   return firstIsThinking ? null : targetMessage.id;
 }
 // src/hooks/session-recovery/storage/thinking-prepend.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
+import { join as join20 } from "path";
 function findLastThinkingContent(sessionID, beforeMessageID) {
   const messages = readMessages(sessionID);
   const currentIndex = messages.findIndex((message) => message.id === beforeMessageID);
@@ -20294,9 +20374,9 @@ function prependThinkingPart(sessionID, messageID) {
     log("[session-recovery] Disabled on SQLite backend: prependThinkingPart (use async variant)");
     return false;
   }
-  const partDir = join19(PART_STORAGE, messageID);
-  if (!existsSync16(partDir)) {
-    mkdirSync5(partDir, { recursive: true });
+  const partDir = join20(PART_STORAGE, messageID);
+  if (!existsSync17(partDir)) {
+    mkdirSync6(partDir, { recursive: true });
   }
   const previousThinking = findLastThinkingContent(sessionID, messageID);
   const partId = `prt_0000000000_${messageID}_thinking`;
@@ -20309,7 +20389,7 @@ function prependThinkingPart(sessionID, messageID) {
     synthetic: true
   };
   try {
-    writeFileSync6(join19(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    writeFileSync7(join20(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
     return true;
   } catch {
     return false;
@@ -20360,23 +20440,23 @@ async function prependThinkingPartAsync(client, sessionID, messageID) {
   }
 }
 // src/hooks/session-recovery/storage/thinking-strip.ts
-import { existsSync as existsSync17, readdirSync as readdirSync6, readFileSync as readFileSync11, unlinkSync as unlinkSync2 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync6, readFileSync as readFileSync12, unlinkSync as unlinkSync2 } from "fs";
+import { join as join21 } from "path";
 function stripThinkingParts(messageID) {
   if (isSqliteBackend()) {
     log("[session-recovery] Disabled on SQLite backend: stripThinkingParts (use async variant)");
     return false;
   }
-  const partDir = join20(PART_STORAGE, messageID);
-  if (!existsSync17(partDir))
+  const partDir = join21(PART_STORAGE, messageID);
+  if (!existsSync18(partDir))
     return false;
   let anyRemoved = false;
   for (const file of readdirSync6(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const filePath = join20(partDir, file);
-      const content = readFileSync11(filePath, "utf-8");
+      const filePath = join21(partDir, file);
+      const content = readFileSync12(filePath, "utf-8");
       const part = JSON.parse(content);
       if (THINKING_TYPES.has(part.type)) {
         unlinkSync2(filePath);
@@ -30833,10 +30913,10 @@ function _property(property, schema2, params) {
     ...normalizeParams(params)
   });
 }
-function _mime(types3, params) {
+function _mime(types4, params) {
   return new $ZodCheckMimeType({
     check: "mime_type",
-    mime: types3,
+    mime: types4,
     ...normalizeParams(params)
   });
 }
@@ -32746,7 +32826,7 @@ var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   ZodType.init(inst, def);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
-  inst.mime = (types3, params) => inst.check(_mime(Array.isArray(types3) ? types3 : [types3], params));
+  inst.mime = (types4, params) => inst.check(_mime(Array.isArray(types4) ? types4 : [types4], params));
 });
 function file(params) {
   return _file(ZodFile, params);
@@ -33068,24 +33148,24 @@ config(en_default());
 var zod_default = exports_external;
 
 // src/hooks/comment-checker/cli-runner.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 
 // src/hooks/comment-checker/cli.ts
 var {spawn: spawn9 } = globalThis.Bun;
 import { createRequire as createRequire2 } from "module";
-import { dirname, join as join22 } from "path";
-import { existsSync as existsSync19 } from "fs";
+import { dirname, join as join23 } from "path";
+import { existsSync as existsSync20 } from "fs";
 import * as fs5 from "fs";
 import { tmpdir as tmpdir3 } from "os";
 
 // src/hooks/comment-checker/downloader.ts
-import { existsSync as existsSync18, appendFileSync as appendFileSync2 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync19, appendFileSync as appendFileSync2 } from "fs";
+import { join as join22 } from "path";
 import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
 import { createRequire } from "module";
 init_logger();
 var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE = join21(tmpdir2(), "comment-checker-debug.log");
+var DEBUG_FILE = join22(tmpdir2(), "comment-checker-debug.log");
 function debugLog(...args) {
   if (DEBUG) {
     const msg = `[${new Date().toISOString()}] [comment-checker:downloader] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
@@ -33104,12 +33184,12 @@ var PLATFORM_MAP = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join21(homedir6(), "AppData", "Local");
-    return join21(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join22(homedir6(), "AppData", "Local");
+    return join22(base2, "oh-my-opencode", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join21(homedir6(), ".cache");
-  return join21(base, "oh-my-opencode", "bin");
+  const base = xdgCache || join22(homedir6(), ".cache");
+  return join22(base, "oh-my-opencode", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
@@ -33135,8 +33215,8 @@ async function downloadCommentChecker() {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName();
-  const binaryPath = join21(cacheDir, binaryName);
-  if (existsSync18(binaryPath)) {
+  const binaryPath = join22(cacheDir, binaryName);
+  if (existsSync19(binaryPath)) {
     debugLog("Binary already cached at:", binaryPath);
     return binaryPath;
   }
@@ -33148,7 +33228,7 @@ async function downloadCommentChecker() {
   log(`[oh-my-opencode] Downloading comment-checker binary...`);
   try {
     ensureCacheDir(cacheDir);
-    const archivePath = join21(cacheDir, assetName);
+    const archivePath = join22(cacheDir, assetName);
     await downloadArchive(downloadUrl, archivePath);
     debugLog(`Downloaded archive to: ${archivePath}`);
     if (ext === "tar.gz") {
@@ -33180,7 +33260,7 @@ async function ensureCommentCheckerBinary() {
 
 // src/hooks/comment-checker/cli.ts
 var DEBUG2 = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE2 = join22(tmpdir3(), "comment-checker-debug.log");
+var DEBUG_FILE2 = join23(tmpdir3(), "comment-checker-debug.log");
 function debugLog2(...args) {
   if (DEBUG2) {
     const msg = `[${new Date().toISOString()}] [comment-checker:cli] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
@@ -33206,8 +33286,8 @@ function findCommentCheckerPathSync() {
     const require2 = createRequire2(import.meta.url);
     const cliPkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
     const cliDir = dirname(cliPkgPath);
-    const binaryPath = join22(cliDir, "bin", binaryName);
-    if (existsSync19(binaryPath)) {
+    const binaryPath = join23(cliDir, "bin", binaryName);
+    if (existsSync20(binaryPath)) {
       debugLog2("found binary in main package:", binaryPath);
       return binaryPath;
     }
@@ -33228,7 +33308,7 @@ async function getCommentCheckerPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findCommentCheckerPathSync();
-    if (syncPath && existsSync19(syncPath)) {
+    if (syncPath && existsSync20(syncPath)) {
       resolvedCliPath = syncPath;
       debugLog2("using sync-resolved path:", syncPath);
       return syncPath;
@@ -33264,7 +33344,7 @@ async function runCommentChecker(input, cliPath, customPrompt) {
     debugLog2("comment-checker binary not found");
     return { hasComments: false, message: "" };
   }
-  if (!existsSync19(binaryPath)) {
+  if (!existsSync20(binaryPath)) {
     debugLog2("comment-checker binary does not exist:", binaryPath);
     return { hasComments: false, message: "" };
   }
@@ -33423,7 +33503,7 @@ ${result.message}`;
   }
 }
 function isCliPathUsable(cliPath) {
-  return Boolean(cliPath && existsSync20(cliPath));
+  return Boolean(cliPath && existsSync21(cliPath));
 }
 
 // src/hooks/comment-checker/pending-calls.ts
@@ -33462,9 +33542,9 @@ function takePendingCall(callID) {
 // src/hooks/comment-checker/hook.ts
 import * as fs6 from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 var DEBUG3 = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE3 = join23(tmpdir4(), "comment-checker-debug.log");
+var DEBUG_FILE3 = join24(tmpdir4(), "comment-checker-debug.log");
 function debugLog3(...args) {
   if (DEBUG3) {
     const msg = `[${new Date().toISOString()}] [comment-checker:hook] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
@@ -33623,16 +33703,16 @@ function createToolOutputTruncatorHook(ctx, options) {
   };
 }
 // src/hooks/directory-agents-injector/injector.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { dirname as dirname3 } from "path";
 
 // src/hooks/directory-agents-injector/finder.ts
-import { existsSync as existsSync21 } from "fs";
-import { dirname as dirname2, join as join25, resolve as resolve2 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { dirname as dirname2, join as join26, resolve as resolve2 } from "path";
 
 // src/hooks/directory-agents-injector/constants.ts
-import { join as join24 } from "path";
-var AGENTS_INJECTOR_STORAGE = join24(OPENCODE_STORAGE, "directory-agents");
+import { join as join25 } from "path";
+var AGENTS_INJECTOR_STORAGE = join25(OPENCODE_STORAGE, "directory-agents");
 var AGENTS_FILENAME = "AGENTS.md";
 
 // src/hooks/directory-agents-injector/finder.ts
@@ -33649,8 +33729,8 @@ function findAgentsMdUp(input) {
   while (true) {
     const isRootDir = current === input.rootDir;
     if (!isRootDir) {
-      const agentsPath = join25(current, AGENTS_FILENAME);
-      if (existsSync21(agentsPath)) {
+      const agentsPath = join26(current, AGENTS_FILENAME);
+      if (existsSync22(agentsPath)) {
         found.push(agentsPath);
       }
     }
@@ -33668,21 +33748,21 @@ function findAgentsMdUp(input) {
 
 // src/shared/session-injected-paths.ts
 import {
-  existsSync as existsSync22,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync12,
+  existsSync as existsSync23,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync13,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function createInjectedPathsStorage(storageDir) {
-  const getStoragePath = (sessionID) => join26(storageDir, `${sessionID}.json`);
+  const getStoragePath = (sessionID) => join27(storageDir, `${sessionID}.json`);
   const loadInjectedPaths = (sessionID) => {
     const filePath = getStoragePath(sessionID);
-    if (!existsSync22(filePath))
+    if (!existsSync23(filePath))
       return new Set;
     try {
-      const content = readFileSync12(filePath, "utf-8");
+      const content = readFileSync13(filePath, "utf-8");
       const data = JSON.parse(content);
       return new Set(data.injectedPaths);
     } catch {
@@ -33690,19 +33770,19 @@ function createInjectedPathsStorage(storageDir) {
     }
   };
   const saveInjectedPaths = (sessionID, paths) => {
-    if (!existsSync22(storageDir)) {
-      mkdirSync6(storageDir, { recursive: true });
+    if (!existsSync23(storageDir)) {
+      mkdirSync7(storageDir, { recursive: true });
     }
     const data = {
       sessionID,
       injectedPaths: [...paths],
       updatedAt: Date.now()
     };
-    writeFileSync7(getStoragePath(sessionID), JSON.stringify(data, null, 2));
+    writeFileSync8(getStoragePath(sessionID), JSON.stringify(data, null, 2));
   };
   const clearInjectedPaths = (sessionID) => {
     const filePath = getStoragePath(sessionID);
-    if (existsSync22(filePath)) {
+    if (existsSync23(filePath)) {
       unlinkSync3(filePath);
     }
   };
@@ -33740,7 +33820,7 @@ async function processFilePathForAgentsInjection(input) {
     if (cache.has(agentsDir))
       continue;
     try {
-      const content = readFileSync13(agentsPath, "utf-8");
+      const content = readFileSync14(agentsPath, "utf-8");
       const { result, truncated } = await input.truncator.truncate(input.sessionID, content);
       const truncationNotice = truncated ? `
 
@@ -33801,16 +33881,16 @@ function createDirectoryAgentsInjectorHook(ctx, modelCacheState) {
   };
 }
 // src/hooks/directory-readme-injector/injector.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 import { dirname as dirname5 } from "path";
 
 // src/hooks/directory-readme-injector/finder.ts
-import { existsSync as existsSync23 } from "fs";
-import { dirname as dirname4, join as join28, resolve as resolve3 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { dirname as dirname4, join as join29, resolve as resolve3 } from "path";
 
 // src/hooks/directory-readme-injector/constants.ts
-import { join as join27 } from "path";
-var README_INJECTOR_STORAGE = join27(OPENCODE_STORAGE, "directory-readme");
+import { join as join28 } from "path";
+var README_INJECTOR_STORAGE = join28(OPENCODE_STORAGE, "directory-readme");
 var README_FILENAME = "README.md";
 
 // src/hooks/directory-readme-injector/finder.ts
@@ -33825,8 +33905,8 @@ function findReadmeMdUp(input) {
   const found = [];
   let current = input.startDir;
   while (true) {
-    const readmePath = join28(current, README_FILENAME);
-    if (existsSync23(readmePath)) {
+    const readmePath = join29(current, README_FILENAME);
+    if (existsSync24(readmePath)) {
       found.push(readmePath);
     }
     if (current === input.rootDir)
@@ -33868,7 +33948,7 @@ async function processFilePathForReadmeInjection(input) {
     if (cache.has(readmeDir))
       continue;
     try {
-      const content = readFileSync14(readmePath, "utf-8");
+      const content = readFileSync15(readmePath, "utf-8");
       const { result, truncated } = await input.truncator.truncate(input.sessionID, content);
       const truncationNotice = truncated ? `
 
@@ -34183,14 +34263,14 @@ function incrementEmptyContentAttempt(autoCompactState, sessionID) {
 }
 
 // src/hooks/anthropic-context-window-limit-recovery/tool-result-storage.ts
-import { existsSync as existsSync25, readdirSync as readdirSync8, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync26, readdirSync as readdirSync8, readFileSync as readFileSync16, writeFileSync as writeFileSync9 } from "fs";
+import { join as join30 } from "path";
 
 // src/hooks/anthropic-context-window-limit-recovery/message-storage-directory.ts
-import { existsSync as existsSync24, readdirSync as readdirSync7 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync7 } from "fs";
 function getMessageIds(sessionID) {
   const messageDir = getMessageDir(sessionID);
-  if (!messageDir || !existsSync24(messageDir))
+  if (!messageDir || !existsSync25(messageDir))
     return [];
   const messageIds = [];
   for (const file2 of readdirSync7(messageDir)) {
@@ -34212,15 +34292,15 @@ function findToolResultsBySize(sessionID) {
   const messageIds = getMessageIds(sessionID);
   const results = [];
   for (const messageID of messageIds) {
-    const partDir = join29(PART_STORAGE, messageID);
-    if (!existsSync25(partDir))
+    const partDir = join30(PART_STORAGE, messageID);
+    if (!existsSync26(partDir))
       continue;
     for (const file2 of readdirSync8(partDir)) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const partPath = join29(partDir, file2);
-        const content = readFileSync15(partPath, "utf-8");
+        const partPath = join30(partDir, file2);
+        const content = readFileSync16(partPath, "utf-8");
         const part = JSON.parse(content);
         if (part.type === "tool" && part.state?.output && !part.truncated) {
           results.push({
@@ -34247,7 +34327,7 @@ function truncateToolResult(partPath) {
     return { success: false };
   }
   try {
-    const content = readFileSync15(partPath, "utf-8");
+    const content = readFileSync16(partPath, "utf-8");
     const part = JSON.parse(content);
     if (!part.state?.output) {
       return { success: false };
@@ -34261,7 +34341,7 @@ function truncateToolResult(partPath) {
       part.state.time = { start: Date.now() };
     }
     part.state.time.compacted = Date.now();
-    writeFileSync8(partPath, JSON.stringify(part, null, 2));
+    writeFileSync9(partPath, JSON.stringify(part, null, 2));
     return { success: true, toolName, originalSize };
   } catch {
     return { success: false };
@@ -34954,8 +35034,8 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
 }
 
 // src/hooks/anthropic-context-window-limit-recovery/pruning-deduplication.ts
-import { readdirSync as readdirSync9, readFileSync as readFileSync16 } from "fs";
-import { join as join30 } from "path";
+import { readdirSync as readdirSync9, readFileSync as readFileSync17 } from "fs";
+import { join as join31 } from "path";
 
 // src/hooks/anthropic-context-window-limit-recovery/pruning-types.ts
 var CHARS_PER_TOKEN = 4;
@@ -34991,7 +35071,7 @@ function readMessages2(sessionID) {
   try {
     const files = readdirSync9(messageDir).filter((f) => f.endsWith(".json"));
     for (const file2 of files) {
-      const content = readFileSync16(join30(messageDir, file2), "utf-8");
+      const content = readFileSync17(join31(messageDir, file2), "utf-8");
       const data = JSON.parse(content);
       if (data.parts) {
         messages.push(data);
@@ -35096,11 +35176,11 @@ function findToolOutput(messages, callID) {
 }
 
 // src/hooks/anthropic-context-window-limit-recovery/pruning-tool-output-truncation.ts
-import { existsSync as existsSync26, readdirSync as readdirSync10, readFileSync as readFileSync17 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync27, readdirSync as readdirSync10, readFileSync as readFileSync18 } from "fs";
+import { join as join32 } from "path";
 init_logger();
 function getPartStorage() {
-  return join31(getOpenCodeStorageDir(), "part");
+  return join32(getOpenCodeStorageDir(), "part");
 }
 function getMessageIds2(sessionID) {
   const messageDir = getMessageDir(sessionID);
@@ -35125,15 +35205,15 @@ async function truncateToolOutputsByCallId(sessionID, callIds, client) {
     return { truncatedCount: 0 };
   let truncatedCount = 0;
   for (const messageID of messageIds) {
-    const partDir = join31(getPartStorage(), messageID);
-    if (!existsSync26(partDir))
+    const partDir = join32(getPartStorage(), messageID);
+    if (!existsSync27(partDir))
       continue;
     for (const file2 of readdirSync10(partDir)) {
       if (!file2.endsWith(".json"))
         continue;
-      const partPath = join31(partDir, file2);
+      const partPath = join32(partDir, file2);
       try {
-        const content = readFileSync17(partPath, "utf-8");
+        const content = readFileSync18(partPath, "utf-8");
         const part = JSON.parse(content);
         if (part.type !== "tool" || !part.callID)
           continue;
@@ -35716,8 +35796,8 @@ function createThinkModeHook() {
   };
 }
 // src/hooks/claude-code-hooks/config.ts
-import { join as join32 } from "path";
-import { existsSync as existsSync27 } from "fs";
+import { join as join33 } from "path";
+import { existsSync as existsSync28 } from "fs";
 function normalizeHookMatcher(raw) {
   return {
     matcher: raw.matcher ?? raw.pattern ?? "*",
@@ -35743,11 +35823,11 @@ function normalizeHooksConfig(raw) {
 function getClaudeSettingsPaths(customPath) {
   const claudeConfigDir = getClaudeConfigDir();
   const paths = [
-    join32(claudeConfigDir, "settings.json"),
-    join32(process.cwd(), ".claude", "settings.json"),
-    join32(process.cwd(), ".claude", "settings.local.json")
+    join33(claudeConfigDir, "settings.json"),
+    join33(process.cwd(), ".claude", "settings.json"),
+    join33(process.cwd(), ".claude", "settings.local.json")
   ];
-  if (customPath && existsSync27(customPath)) {
+  if (customPath && existsSync28(customPath)) {
     paths.unshift(customPath);
   }
   return [...new Set(paths)];
@@ -35772,7 +35852,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
   const paths = getClaudeSettingsPaths(customSettingsPath);
   let mergedConfig = {};
   for (const settingsPath of paths) {
-    if (existsSync27(settingsPath)) {
+    if (existsSync28(settingsPath)) {
       try {
         const content = await Bun.file(settingsPath).text();
         const settings = JSON.parse(content);
@@ -35790,14 +35870,14 @@ async function loadClaudeHooksConfig(customSettingsPath) {
 
 // src/hooks/claude-code-hooks/config-loader.ts
 init_logger();
-import { existsSync as existsSync28 } from "fs";
-import { join as join33 } from "path";
-var USER_CONFIG_PATH = join33(getOpenCodeConfigDir({ binary: "opencode" }), "opencode-cc-plugin.json");
+import { existsSync as existsSync29 } from "fs";
+import { join as join34 } from "path";
+var USER_CONFIG_PATH = join34(getOpenCodeConfigDir({ binary: "opencode" }), "opencode-cc-plugin.json");
 function getProjectConfigPath() {
-  return join33(process.cwd(), ".opencode", "opencode-cc-plugin.json");
+  return join34(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 async function loadConfigFromPath(path5) {
-  if (!existsSync28(path5)) {
+  if (!existsSync29(path5)) {
     return null;
   }
   try {
@@ -35939,17 +36019,17 @@ ${USER_PROMPT_SUBMIT_TAG_CLOSE}`);
 }
 
 // src/hooks/claude-code-hooks/transcript.ts
-import { join as join34 } from "path";
-import { mkdirSync as mkdirSync7, appendFileSync as appendFileSync5, existsSync as existsSync29, writeFileSync as writeFileSync9, unlinkSync as unlinkSync4 } from "fs";
+import { join as join35 } from "path";
+import { mkdirSync as mkdirSync8, appendFileSync as appendFileSync5, existsSync as existsSync30, writeFileSync as writeFileSync10, unlinkSync as unlinkSync4 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
 import { randomUUID } from "crypto";
-var TRANSCRIPT_DIR = join34(getClaudeConfigDir(), "transcripts");
+var TRANSCRIPT_DIR = join35(getClaudeConfigDir(), "transcripts");
 function getTranscriptPath(sessionId) {
-  return join34(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
+  return join35(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
 }
 function ensureTranscriptDir() {
-  if (!existsSync29(TRANSCRIPT_DIR)) {
-    mkdirSync7(TRANSCRIPT_DIR, { recursive: true });
+  if (!existsSync30(TRANSCRIPT_DIR)) {
+    mkdirSync8(TRANSCRIPT_DIR, { recursive: true });
   }
 }
 function appendTranscriptEntry(sessionId, entry) {
@@ -36031,8 +36111,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
       });
     }
     const allEntries = [...baseEntries, buildCurrentEntry(currentToolName, currentToolInput)];
-    const tempPath = join34(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-    writeFileSync9(tempPath, allEntries.join(`
+    const tempPath = join35(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+    writeFileSync10(tempPath, allEntries.join(`
 `) + `
 `);
     const cacheEntry = transcriptCache.get(sessionId);
@@ -36042,8 +36122,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
     return tempPath;
   } catch {
     try {
-      const tempPath = join34(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-      writeFileSync9(tempPath, buildCurrentEntry(currentToolName, currentToolInput) + `
+      const tempPath = join35(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+      writeFileSync10(tempPath, buildCurrentEntry(currentToolName, currentToolInput) + `
 `);
       return tempPath;
     } catch {
@@ -36260,10 +36340,10 @@ function createPreCompactHandler(ctx, config2) {
 }
 
 // src/hooks/claude-code-hooks/todo.ts
-import { join as join35 } from "path";
-var TODO_DIR = join35(getClaudeConfigDir(), "todos");
+import { join as join36 } from "path";
+var TODO_DIR = join36(getClaudeConfigDir(), "todos");
 function getTodoPath(sessionId) {
-  return join35(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
+  return join36(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
 }
 
 // src/hooks/claude-code-hooks/stop.ts
@@ -36838,17 +36918,17 @@ function getRuleInjectionFilePath(output) {
 
 // src/hooks/rules-injector/storage.ts
 import {
-  existsSync as existsSync30,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync18,
-  writeFileSync as writeFileSync10,
+  existsSync as existsSync31,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync19,
+  writeFileSync as writeFileSync11,
   unlinkSync as unlinkSync5
 } from "fs";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 
 // src/hooks/rules-injector/constants.ts
-import { join as join36 } from "path";
-var RULES_INJECTOR_STORAGE = join36(OPENCODE_STORAGE, "rules-injector");
+import { join as join37 } from "path";
+var RULES_INJECTOR_STORAGE = join37(OPENCODE_STORAGE, "rules-injector");
 var PROJECT_MARKERS = [
   ".git",
   "pyproject.toml",
@@ -36872,14 +36952,14 @@ var RULE_EXTENSIONS = [".md", ".mdc"];
 
 // src/hooks/rules-injector/storage.ts
 function getStoragePath(sessionID) {
-  return join37(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join38(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedRules(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (!existsSync30(filePath))
+  if (!existsSync31(filePath))
     return { contentHashes: new Set, realPaths: new Set };
   try {
-    const content = readFileSync18(filePath, "utf-8");
+    const content = readFileSync19(filePath, "utf-8");
     const data = JSON.parse(content);
     return {
       contentHashes: new Set(data.injectedHashes),
@@ -36890,8 +36970,8 @@ function loadInjectedRules(sessionID) {
   }
 }
 function saveInjectedRules(sessionID, data) {
-  if (!existsSync30(RULES_INJECTOR_STORAGE)) {
-    mkdirSync8(RULES_INJECTOR_STORAGE, { recursive: true });
+  if (!existsSync31(RULES_INJECTOR_STORAGE)) {
+    mkdirSync9(RULES_INJECTOR_STORAGE, { recursive: true });
   }
   const storageData = {
     sessionID,
@@ -36899,11 +36979,11 @@ function saveInjectedRules(sessionID, data) {
     injectedRealPaths: [...data.realPaths],
     updatedAt: Date.now()
   };
-  writeFileSync10(getStoragePath(sessionID), JSON.stringify(storageData, null, 2));
+  writeFileSync11(getStoragePath(sessionID), JSON.stringify(storageData, null, 2));
 }
 function clearInjectedRules(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (existsSync30(filePath)) {
+  if (existsSync31(filePath)) {
     unlinkSync5(filePath);
   }
 }
@@ -36925,13 +37005,13 @@ function createSessionCacheStore() {
 }
 
 // src/hooks/rules-injector/injector.ts
-import { readFileSync as readFileSync19, statSync as statSync4 } from "fs";
+import { readFileSync as readFileSync20, statSync as statSync4 } from "fs";
 import { homedir as homedir7 } from "os";
 import { relative as relative2, resolve as resolve4 } from "path";
 
 // src/hooks/rules-injector/project-root-finder.ts
-import { existsSync as existsSync31, statSync as statSync2 } from "fs";
-import { dirname as dirname6, join as join38 } from "path";
+import { existsSync as existsSync32, statSync as statSync2 } from "fs";
+import { dirname as dirname6, join as join39 } from "path";
 function findProjectRoot(startPath) {
   let current;
   try {
@@ -36942,8 +37022,8 @@ function findProjectRoot(startPath) {
   }
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      const markerPath = join38(current, marker);
-      if (existsSync31(markerPath)) {
+      const markerPath = join39(current, marker);
+      if (existsSync32(markerPath)) {
         return current;
       }
     }
@@ -36955,12 +37035,12 @@ function findProjectRoot(startPath) {
   }
 }
 // src/hooks/rules-injector/rule-file-finder.ts
-import { existsSync as existsSync33, statSync as statSync3 } from "fs";
-import { dirname as dirname7, join as join40 } from "path";
+import { existsSync as existsSync34, statSync as statSync3 } from "fs";
+import { dirname as dirname7, join as join41 } from "path";
 
 // src/hooks/rules-injector/rule-file-scanner.ts
-import { existsSync as existsSync32, readdirSync as readdirSync11, realpathSync as realpathSync2 } from "fs";
-import { join as join39 } from "path";
+import { existsSync as existsSync33, readdirSync as readdirSync11, realpathSync as realpathSync2 } from "fs";
+import { join as join40 } from "path";
 function isGitHubInstructionsDir(dir) {
   return dir.includes(".github/instructions") || dir.endsWith(".github/instructions");
 }
@@ -36971,12 +37051,12 @@ function isValidRuleFile(fileName, dir) {
   return RULE_EXTENSIONS.some((ext) => fileName.endsWith(ext));
 }
 function findRuleFilesRecursive(dir, results) {
-  if (!existsSync32(dir))
+  if (!existsSync33(dir))
     return;
   try {
     const entries = readdirSync11(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join39(dir, entry.name);
+      const fullPath = join40(dir, entry.name);
       if (entry.isDirectory()) {
         findRuleFilesRecursive(fullPath, results);
       } else if (entry.isFile()) {
@@ -37003,7 +37083,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
   let distance = 0;
   while (true) {
     for (const [parent, subdir] of PROJECT_RULE_SUBDIRS) {
-      const ruleDir = join40(currentDir, parent, subdir);
+      const ruleDir = join41(currentDir, parent, subdir);
       const files = [];
       findRuleFilesRecursive(ruleDir, files);
       for (const filePath of files) {
@@ -37029,8 +37109,8 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
   }
   if (projectRoot) {
     for (const ruleFile of PROJECT_RULE_FILES) {
-      const filePath = join40(projectRoot, ruleFile);
-      if (existsSync33(filePath)) {
+      const filePath = join41(projectRoot, ruleFile);
+      if (existsSync34(filePath)) {
         try {
           const stat = statSync3(filePath);
           if (stat.isFile()) {
@@ -37050,7 +37130,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
       }
     }
   }
-  const userRuleDir = join40(homeDir, USER_RULE_DIR);
+  const userRuleDir = join41(homeDir, USER_RULE_DIR);
   const userFiles = [];
   findRuleFilesRecursive(userRuleDir, userFiles);
   for (const filePath of userFiles) {
@@ -37245,7 +37325,7 @@ function getCachedParsedRule(filePath, realPath) {
     if (cached2 && cached2.mtimeMs === stat.mtimeMs && cached2.size === stat.size) {
       return { metadata: cached2.metadata, body: cached2.body };
     }
-    const rawContent = readFileSync19(filePath, "utf-8");
+    const rawContent = readFileSync20(filePath, "utf-8");
     const { metadata, body } = parseRuleFrontmatter(rawContent);
     parsedRuleCache.set(realPath, {
       mtimeMs: stat.mtimeMs,
@@ -37255,7 +37335,7 @@ function getCachedParsedRule(filePath, realPath) {
     });
     return { metadata, body };
   } catch {
-    const rawContent = readFileSync19(filePath, "utf-8");
+    const rawContent = readFileSync20(filePath, "utf-8");
     return parseRuleFrontmatter(rawContent);
   }
 }
@@ -38031,17 +38111,17 @@ v${latestVersion} available. Restart OpenCode to apply.` : "OpenCode is now on S
 }
 // src/hooks/agent-usage-reminder/storage.ts
 import {
-  existsSync as existsSync39,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync27,
-  writeFileSync as writeFileSync13,
+  existsSync as existsSync40,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync28,
+  writeFileSync as writeFileSync14,
   unlinkSync as unlinkSync6
 } from "fs";
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 
 // src/hooks/agent-usage-reminder/constants.ts
-import { join as join45 } from "path";
-var AGENT_USAGE_REMINDER_STORAGE = join45(OPENCODE_STORAGE, "agent-usage-reminder");
+import { join as join46 } from "path";
+var AGENT_USAGE_REMINDER_STORAGE = join46(OPENCODE_STORAGE, "agent-usage-reminder");
 var TARGET_TOOLS = new Set([
   "grep",
   "safe_grep",
@@ -38087,29 +38167,29 @@ ALWAYS prefer: Multiple parallel task calls > Direct tool calls
 
 // src/hooks/agent-usage-reminder/storage.ts
 function getStoragePath2(sessionID) {
-  return join46(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
+  return join47(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
 }
 function loadAgentUsageState(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (!existsSync39(filePath))
+  if (!existsSync40(filePath))
     return null;
   try {
-    const content = readFileSync27(filePath, "utf-8");
+    const content = readFileSync28(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function saveAgentUsageState(state3) {
-  if (!existsSync39(AGENT_USAGE_REMINDER_STORAGE)) {
-    mkdirSync9(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
+  if (!existsSync40(AGENT_USAGE_REMINDER_STORAGE)) {
+    mkdirSync10(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath2(state3.sessionID);
-  writeFileSync13(filePath, JSON.stringify(state3, null, 2));
+  writeFileSync14(filePath, JSON.stringify(state3, null, 2));
 }
 function clearAgentUsageState(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (existsSync39(filePath)) {
+  if (existsSync40(filePath)) {
     unlinkSync6(filePath);
   }
 }
@@ -38814,10 +38894,10 @@ function resolveMessage(message, agentName, modelID) {
 }
 function detectKeywordsWithType(text, agentName, modelID) {
   const textWithoutCode = removeCodeBlocks2(text);
-  const types4 = ["ultrawork", "search", "analyze"];
+  const types5 = ["ultrawork", "search", "analyze"];
   return KEYWORD_DETECTORS.map(({ pattern, message }, index) => ({
     matches: pattern.test(textWithoutCode),
-    type: types4[index],
+    type: types5[index],
     message: resolveMessage(message, agentName, modelID)
   })).filter((result) => result.matches).map(({ type: type2, message }) => ({ type: type2, message }));
 }
@@ -38999,17 +39079,17 @@ function createNonInteractiveEnvHook(_ctx) {
 }
 // src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync40,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync28,
-  writeFileSync as writeFileSync14,
+  existsSync as existsSync41,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync29,
+  writeFileSync as writeFileSync15,
   unlinkSync as unlinkSync7
 } from "fs";
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 
 // src/hooks/interactive-bash-session/constants.ts
-import { join as join47 } from "path";
-var INTERACTIVE_BASH_SESSION_STORAGE = join47(OPENCODE_STORAGE, "interactive-bash-session");
+import { join as join48 } from "path";
+var INTERACTIVE_BASH_SESSION_STORAGE = join48(OPENCODE_STORAGE, "interactive-bash-session");
 var OMO_SESSION_PREFIX = "omo-";
 function buildSessionReminderMessage(sessions) {
   if (sessions.length === 0)
@@ -39021,14 +39101,14 @@ function buildSessionReminderMessage(sessions) {
 
 // src/hooks/interactive-bash-session/storage.ts
 function getStoragePath3(sessionID) {
-  return join48(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+  return join49(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
 }
 function loadInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (!existsSync40(filePath))
+  if (!existsSync41(filePath))
     return null;
   try {
-    const content = readFileSync28(filePath, "utf-8");
+    const content = readFileSync29(filePath, "utf-8");
     const serialized = JSON.parse(content);
     return {
       sessionID: serialized.sessionID,
@@ -39040,8 +39120,8 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state3) {
-  if (!existsSync40(INTERACTIVE_BASH_SESSION_STORAGE)) {
-    mkdirSync10(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
+  if (!existsSync41(INTERACTIVE_BASH_SESSION_STORAGE)) {
+    mkdirSync11(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath3(state3.sessionID);
   const serialized = {
@@ -39049,11 +39129,11 @@ function saveInteractiveBashSessionState(state3) {
     tmuxSessions: Array.from(state3.tmuxSessions),
     updatedAt: state3.updatedAt
   };
-  writeFileSync14(filePath, JSON.stringify(serialized, null, 2));
+  writeFileSync15(filePath, JSON.stringify(serialized, null, 2));
 }
 function clearInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (existsSync40(filePath)) {
+  if (existsSync41(filePath)) {
     unlinkSync7(filePath);
   }
 }
@@ -39449,18 +39529,18 @@ var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
 var DEFAULT_MAX_ITERATIONS = 100;
 var DEFAULT_COMPLETION_PROMISE = "DONE";
 // src/hooks/ralph-loop/storage.ts
-import { existsSync as existsSync41, readFileSync as readFileSync29, writeFileSync as writeFileSync15, unlinkSync as unlinkSync8, mkdirSync as mkdirSync11 } from "fs";
-import { dirname as dirname10, join as join49 } from "path";
+import { existsSync as existsSync42, readFileSync as readFileSync30, writeFileSync as writeFileSync16, unlinkSync as unlinkSync8, mkdirSync as mkdirSync12 } from "fs";
+import { dirname as dirname10, join as join50 } from "path";
 function getStateFilePath(directory, customPath) {
-  return customPath ? join49(directory, customPath) : join49(directory, DEFAULT_STATE_FILE);
+  return customPath ? join50(directory, customPath) : join50(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync41(filePath)) {
+  if (!existsSync42(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync29(filePath, "utf-8");
+    const content = readFileSync30(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -39494,8 +39574,8 @@ function writeState(directory, state3, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
     const dir = dirname10(filePath);
-    if (!existsSync41(dir)) {
-      mkdirSync11(dir, { recursive: true });
+    if (!existsSync42(dir)) {
+      mkdirSync12(dir, { recursive: true });
     }
     const sessionIdLine = state3.session_id ? `session_id: "${state3.session_id}"
 ` : "";
@@ -39510,7 +39590,7 @@ started_at: "${state3.started_at}"
 ${sessionIdLine}${ultraworkLine}---
 ${state3.prompt}
 `;
-    writeFileSync15(filePath, content, "utf-8");
+    writeFileSync16(filePath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -39519,7 +39599,7 @@ ${state3.prompt}
 function clearState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
-    if (existsSync41(filePath)) {
+    if (existsSync42(filePath)) {
       unlinkSync8(filePath);
     }
     return true;
@@ -39622,7 +39702,7 @@ init_logger();
 
 // src/hooks/ralph-loop/completion-promise-detector.ts
 init_logger();
-import { existsSync as existsSync42, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync31 } from "fs";
 
 // src/hooks/ralph-loop/with-timeout.ts
 async function withTimeout(promise2, timeoutMs) {
@@ -39652,9 +39732,9 @@ function detectCompletionInTranscript(transcriptPath, promise2) {
   if (!transcriptPath)
     return false;
   try {
-    if (!existsSync42(transcriptPath))
+    if (!existsSync43(transcriptPath))
       return false;
-    const content = readFileSync30(transcriptPath, "utf-8");
+    const content = readFileSync31(transcriptPath, "utf-8");
     const pattern = buildPromisePattern(promise2);
     const lines = content.split(`
 `).filter((line) => line.trim());
@@ -39936,6 +40016,33 @@ function createRalphLoopHook(ctx, options) {
     getState: loopState.getState
   };
 }
+// src/hooks/sisyphus-gpt-hephaestus-reminder/hook.ts
+var TOAST_TITLE = "Use Hephaestus for GPT Models";
+var TOAST_MESSAGE = "Sisyphus is using a GPT model. Use Hephaestus and include 'ulw' in your prompt.";
+function createSisyphusGptHephaestusReminderHook(ctx) {
+  return {
+    "chat.message": async (input) => {
+      const agentName = (input.agent ?? getSessionAgent(input.sessionID) ?? "").toLowerCase();
+      const modelID = input.model?.modelID?.toLowerCase() ?? "";
+      if (agentName !== "sisyphus" || !modelID.includes("gpt")) {
+        return;
+      }
+      await ctx.client.tui.showToast({
+        body: {
+          title: TOAST_TITLE,
+          message: TOAST_MESSAGE,
+          variant: "error",
+          duration: 5000
+        }
+      }).catch((error45) => {
+        log("[sisyphus-gpt-hephaestus-reminder] Failed to show toast", {
+          sessionID: input.sessionID,
+          error: error45
+        });
+      });
+    }
+  };
+}
 // src/hooks/auto-slash-command/constants.ts
 var AUTO_SLASH_COMMAND_TAG_OPEN = "<auto-slash-command>";
 var AUTO_SLASH_COMMAND_TAG_CLOSE = "</auto-slash-command>";
@@ -40009,8 +40116,8 @@ function findSlashCommandPartIndex(parts) {
   return -1;
 }
 // src/hooks/auto-slash-command/executor.ts
-import { existsSync as existsSync44, readdirSync as readdirSync12, readFileSync as readFileSync33 } from "fs";
-import { join as join55, basename as basename2, dirname as dirname13 } from "path";
+import { existsSync as existsSync45, readdirSync as readdirSync12, readFileSync as readFileSync34 } from "fs";
+import { join as join56, basename as basename2, dirname as dirname13 } from "path";
 // src/features/builtin-commands/templates/init-deep.ts
 var INIT_DEEP_TEMPLATE = `# /init-deep
 
@@ -41346,7 +41453,7 @@ function loadBuiltinCommands(disabledCommands) {
   return commands;
 }
 // src/features/opencode-skill-loader/loader.ts
-import { join as join53 } from "path";
+import { join as join54 } from "path";
 import { homedir as homedir10 } from "os";
 
 // src/features/opencode-skill-loader/skill-definition-record.ts
@@ -41374,17 +41481,17 @@ function deduplicateSkillsByName(skills) {
 
 // src/features/opencode-skill-loader/skill-directory-loader.ts
 import { promises as fs16 } from "fs";
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 
 // src/features/opencode-skill-loader/loaded-skill-from-path.ts
 import { promises as fs15 } from "fs";
 import { basename } from "path";
 
 // src/shared/skill-path-resolver.ts
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 function resolveSkillPathReferences(content, basePath) {
   const normalizedBase = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
-  return content.replace(/(?<![a-zA-Z0-9])@([a-zA-Z0-9_-]+\/[a-zA-Z0-9_.\-\/]*)/g, (_, relativePath) => join50(normalizedBase, relativePath));
+  return content.replace(/(?<![a-zA-Z0-9])@([a-zA-Z0-9_-]+\/[a-zA-Z0-9_.\-\/]*)/g, (_, relativePath) => join51(normalizedBase, relativePath));
 }
 
 // src/features/opencode-skill-loader/allowed-tools-parser.ts
@@ -41399,7 +41506,7 @@ function parseAllowedTools(allowedTools) {
 
 // src/features/opencode-skill-loader/skill-mcp-config.ts
 import { promises as fs14 } from "fs";
-import { join as join51 } from "path";
+import { join as join52 } from "path";
 function parseSkillMcpConfigFromFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!frontmatterMatch)
@@ -41415,7 +41522,7 @@ function parseSkillMcpConfigFromFrontmatter(content) {
   return;
 }
 async function loadMcpJsonFromDir(skillDir) {
-  const mcpJsonPath = join51(skillDir, "mcp.json");
+  const mcpJsonPath = join52(skillDir, "mcp.json");
   try {
     const content = await fs14.readFile(mcpJsonPath, "utf-8");
     const parsed = JSON.parse(content);
@@ -41504,10 +41611,10 @@ async function loadSkillsFromDir(options) {
   const directories = entries.filter((entry) => !entry.name.startsWith(".") && (entry.isDirectory() || entry.isSymbolicLink()));
   const files = entries.filter((entry) => !entry.name.startsWith(".") && !entry.isDirectory() && !entry.isSymbolicLink() && isMarkdownFile(entry));
   for (const entry of directories) {
-    const entryPath = join52(options.skillsDir, entry.name);
+    const entryPath = join53(options.skillsDir, entry.name);
     const resolvedPath = await resolveSymlinkAsync(entryPath);
     const dirName = entry.name;
-    const skillMdPath = join52(resolvedPath, "SKILL.md");
+    const skillMdPath = join53(resolvedPath, "SKILL.md");
     try {
       await fs16.access(skillMdPath);
       const skill = await loadSkillFromPath({
@@ -41522,7 +41629,7 @@ async function loadSkillsFromDir(options) {
       }
       continue;
     } catch {}
-    const namedSkillMdPath = join52(resolvedPath, `${dirName}.md`);
+    const namedSkillMdPath = join53(resolvedPath, `${dirName}.md`);
     try {
       await fs16.access(namedSkillMdPath);
       const skill = await loadSkillFromPath({
@@ -41554,7 +41661,7 @@ async function loadSkillsFromDir(options) {
     }
   }
   for (const entry of files) {
-    const entryPath = join52(options.skillsDir, entry.name);
+    const entryPath = join53(options.skillsDir, entry.name);
     const baseName = inferSkillNameFromFileName(entryPath);
     const skill = await loadSkillFromPath({
       skillPath: entryPath,
@@ -41572,23 +41679,23 @@ async function loadSkillsFromDir(options) {
 
 // src/features/opencode-skill-loader/loader.ts
 async function loadUserSkills() {
-  const userSkillsDir = join53(getClaudeConfigDir(), "skills");
+  const userSkillsDir = join54(getClaudeConfigDir(), "skills");
   const skills = await loadSkillsFromDir({ skillsDir: userSkillsDir, scope: "user" });
   return skillsToCommandDefinitionRecord(skills);
 }
 async function loadProjectSkills(directory) {
-  const projectSkillsDir = join53(directory ?? process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join54(directory ?? process.cwd(), ".claude", "skills");
   const skills = await loadSkillsFromDir({ skillsDir: projectSkillsDir, scope: "project" });
   return skillsToCommandDefinitionRecord(skills);
 }
 async function loadOpencodeGlobalSkills() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeSkillsDir = join53(configDir, "skills");
+  const opencodeSkillsDir = join54(configDir, "skills");
   const skills = await loadSkillsFromDir({ skillsDir: opencodeSkillsDir, scope: "opencode" });
   return skillsToCommandDefinitionRecord(skills);
 }
 async function loadOpencodeProjectSkills(directory) {
-  const opencodeProjectDir = join53(directory ?? process.cwd(), ".opencode", "skills");
+  const opencodeProjectDir = join54(directory ?? process.cwd(), ".opencode", "skills");
   const skills = await loadSkillsFromDir({ skillsDir: opencodeProjectDir, scope: "opencode-project" });
   return skillsToCommandDefinitionRecord(skills);
 }
@@ -41635,28 +41742,28 @@ async function discoverSkills(options = {}) {
   ]);
 }
 async function discoverUserClaudeSkills() {
-  const userSkillsDir = join53(getClaudeConfigDir(), "skills");
+  const userSkillsDir = join54(getClaudeConfigDir(), "skills");
   return loadSkillsFromDir({ skillsDir: userSkillsDir, scope: "user" });
 }
 async function discoverProjectClaudeSkills(directory) {
-  const projectSkillsDir = join53(directory ?? process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join54(directory ?? process.cwd(), ".claude", "skills");
   return loadSkillsFromDir({ skillsDir: projectSkillsDir, scope: "project" });
 }
 async function discoverOpencodeGlobalSkills() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeSkillsDir = join53(configDir, "skills");
+  const opencodeSkillsDir = join54(configDir, "skills");
   return loadSkillsFromDir({ skillsDir: opencodeSkillsDir, scope: "opencode" });
 }
 async function discoverOpencodeProjectSkills(directory) {
-  const opencodeProjectDir = join53(directory ?? process.cwd(), ".opencode", "skills");
+  const opencodeProjectDir = join54(directory ?? process.cwd(), ".opencode", "skills");
   return loadSkillsFromDir({ skillsDir: opencodeProjectDir, scope: "opencode-project" });
 }
 async function discoverProjectAgentsSkills(directory) {
-  const agentsProjectDir = join53(directory ?? process.cwd(), ".agents", "skills");
+  const agentsProjectDir = join54(directory ?? process.cwd(), ".agents", "skills");
   return loadSkillsFromDir({ skillsDir: agentsProjectDir, scope: "project" });
 }
 async function discoverGlobalAgentsSkills() {
-  const agentsGlobalDir = join53(homedir10(), ".agents", "skills");
+  const agentsGlobalDir = join54(homedir10(), ".agents", "skills");
   return loadSkillsFromDir({ skillsDir: agentsGlobalDir, scope: "user" });
 }
 // src/features/opencode-skill-loader/merger/builtin-skill-converter.ts
@@ -41683,7 +41790,7 @@ function builtinToLoadedSkill(builtin) {
 }
 
 // src/features/opencode-skill-loader/merger/config-skill-entry-loader.ts
-import { existsSync as existsSync43, readFileSync as readFileSync31 } from "fs";
+import { existsSync as existsSync44, readFileSync as readFileSync32 } from "fs";
 import { dirname as dirname11, isAbsolute as isAbsolute2, resolve as resolve5 } from "path";
 import { homedir as homedir11 } from "os";
 function resolveFilePath5(from, configDir) {
@@ -41702,9 +41809,9 @@ function resolveFilePath5(from, configDir) {
 }
 function loadSkillFromFile(filePath) {
   try {
-    if (!existsSync43(filePath))
+    if (!existsSync44(filePath))
       return null;
-    const content = readFileSync31(filePath, "utf-8");
+    const content = readFileSync32(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     return { template: body, metadata: data };
   } catch {
@@ -43920,10 +44027,10 @@ async function getAllSkills(options) {
   return allSkills;
 }
 // src/features/opencode-skill-loader/loaded-skill-template-extractor.ts
-import { readFileSync as readFileSync32 } from "fs";
+import { readFileSync as readFileSync33 } from "fs";
 function extractSkillTemplate(skill) {
   if (skill.path) {
-    const content = readFileSync32(skill.path, "utf-8");
+    const content = readFileSync33(skill.path, "utf-8");
     const { body } = parseFrontmatter(content);
     return body.trim();
   }
@@ -44034,7 +44141,7 @@ async function resolveMultipleSkillsAsync(skillNames, options) {
 // src/features/opencode-skill-loader/config-source-discovery.ts
 var import_picomatch2 = __toESM(require_picomatch2(), 1);
 import { promises as fs17 } from "fs";
-import { dirname as dirname12, extname, isAbsolute as isAbsolute3, join as join54, relative as relative3 } from "path";
+import { dirname as dirname12, extname, isAbsolute as isAbsolute3, join as join55, relative as relative3 } from "path";
 var MAX_RECURSIVE_DEPTH = 10;
 function isHttpUrl(path10) {
   return path10.startsWith("http://") || path10.startsWith("https://");
@@ -44043,7 +44150,7 @@ function toAbsolutePath(path10, configDir) {
   if (isAbsolute3(path10)) {
     return path10;
   }
-  return join54(configDir, path10);
+  return join55(configDir, path10);
 }
 function isMarkdownPath(path10) {
   return extname(path10).toLowerCase() === ".md";
@@ -44114,7 +44221,7 @@ async function discoverConfigSourceSkills(options) {
 }
 // src/hooks/auto-slash-command/executor.ts
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync44(commandsDir)) {
+  if (!existsSync45(commandsDir)) {
     return [];
   }
   const entries = readdirSync12(commandsDir, { withFileTypes: true });
@@ -44122,10 +44229,10 @@ function discoverCommandsFromDir(commandsDir, scope) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join55(commandsDir, entry.name);
+    const commandPath = join56(commandsDir, entry.name);
     const commandName = basename2(entry.name, ".md");
     try {
-      const content = readFileSync33(commandPath, "utf-8");
+      const content = readFileSync34(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -44168,10 +44275,10 @@ function skillToCommandInfo(skill) {
 }
 async function discoverAllCommands(options) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const userCommandsDir = join55(getClaudeConfigDir(), "commands");
-  const projectCommandsDir = join55(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join55(configDir, "command");
-  const opencodeProjectDir = join55(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join56(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join56(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join56(configDir, "command");
+  const opencodeProjectDir = join56(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
@@ -44400,6 +44507,58 @@ ${EDIT_ERROR_REMINDER}`;
     }
   };
 }
+// src/hooks/json-error-recovery/hook.ts
+var JSON_ERROR_TOOL_EXCLUDE_LIST = [
+  "bash",
+  "read",
+  "glob",
+  "grep",
+  "webfetch",
+  "look_at",
+  "grep_app_searchgithub",
+  "websearch_web_search_exa"
+];
+var JSON_ERROR_PATTERNS = [
+  /json parse error/i,
+  /failed to parse json/i,
+  /invalid json/i,
+  /malformed json/i,
+  /unexpected end of json input/i,
+  /syntaxerror:\s*unexpected token.*json/i,
+  /json[^\n]*expected '\}'/i,
+  /json[^\n]*unexpected eof/i
+];
+var JSON_ERROR_REMINDER_MARKER = "[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]";
+var JSON_ERROR_EXCLUDED_TOOLS = new Set(JSON_ERROR_TOOL_EXCLUDE_LIST);
+var JSON_ERROR_REMINDER = `
+[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]
+
+You sent invalid JSON arguments. The system could not parse your tool call.
+STOP and do this NOW:
+
+1. LOOK at the error message above to see what was expected vs what you sent.
+2. CORRECT your JSON syntax (missing braces, unescaped quotes, trailing commas, etc).
+3. RETRY the tool call with valid JSON.
+
+DO NOT repeat the exact same invalid call.
+`;
+function createJsonErrorRecoveryHook(_ctx) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      if (JSON_ERROR_EXCLUDED_TOOLS.has(input.tool.toLowerCase()))
+        return;
+      if (typeof output.output !== "string")
+        return;
+      if (output.output.includes(JSON_ERROR_REMINDER_MARKER))
+        return;
+      const hasJsonError = JSON_ERROR_PATTERNS.some((pattern) => pattern.test(output.output));
+      if (hasJsonError) {
+        output.output += `
+${JSON_ERROR_REMINDER}`;
+      }
+    }
+  };
+}
 // src/hooks/prometheus-md-only/constants.ts
 var HOOK_NAME4 = "prometheus-md-only";
 var PROMETHEUS_AGENT = "prometheus";
@@ -44479,18 +44638,18 @@ var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 var PROMETHEUS_PLANS_DIR = ".sisyphus/plans";
 // src/features/boulder-state/storage.ts
-import { existsSync as existsSync45, readFileSync as readFileSync34, writeFileSync as writeFileSync16, mkdirSync as mkdirSync12, readdirSync as readdirSync13 } from "fs";
-import { dirname as dirname14, join as join56, basename as basename3 } from "path";
+import { existsSync as existsSync46, readFileSync as readFileSync35, writeFileSync as writeFileSync17, mkdirSync as mkdirSync13, readdirSync as readdirSync13 } from "fs";
+import { dirname as dirname14, join as join57, basename as basename3 } from "path";
 function getBoulderFilePath(directory) {
-  return join56(directory, BOULDER_DIR, BOULDER_FILE);
+  return join57(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync45(filePath)) {
+  if (!existsSync46(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync34(filePath, "utf-8");
+    const content = readFileSync35(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
@@ -44507,10 +44666,10 @@ function writeBoulderState(directory, state3) {
   const filePath = getBoulderFilePath(directory);
   try {
     const dir = dirname14(filePath);
-    if (!existsSync45(dir)) {
-      mkdirSync12(dir, { recursive: true });
+    if (!existsSync46(dir)) {
+      mkdirSync13(dir, { recursive: true });
     }
-    writeFileSync16(filePath, JSON.stringify(state3, null, 2), "utf-8");
+    writeFileSync17(filePath, JSON.stringify(state3, null, 2), "utf-8");
     return true;
   } catch {
     return false;
@@ -44534,7 +44693,7 @@ function appendSessionId(directory, sessionId) {
 function clearBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
   try {
-    if (existsSync45(filePath)) {
+    if (existsSync46(filePath)) {
       const { unlinkSync: unlinkSync9 } = __require("fs");
       unlinkSync9(filePath);
     }
@@ -44544,13 +44703,13 @@ function clearBoulderState(directory) {
   }
 }
 function findPrometheusPlans(directory) {
-  const plansDir = join56(directory, PROMETHEUS_PLANS_DIR);
-  if (!existsSync45(plansDir)) {
+  const plansDir = join57(directory, PROMETHEUS_PLANS_DIR);
+  if (!existsSync46(plansDir)) {
     return [];
   }
   try {
     const files = readdirSync13(plansDir);
-    return files.filter((f) => f.endsWith(".md")).map((f) => join56(plansDir, f)).sort((a, b) => {
+    return files.filter((f) => f.endsWith(".md")).map((f) => join57(plansDir, f)).sort((a, b) => {
       const aStat = __require("fs").statSync(a);
       const bStat = __require("fs").statSync(b);
       return bStat.mtimeMs - aStat.mtimeMs;
@@ -44560,11 +44719,11 @@ function findPrometheusPlans(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync45(planPath)) {
+  if (!existsSync46(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync34(planPath, "utf-8");
+    const content = readFileSync35(planPath, "utf-8");
     const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) || [];
     const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) || [];
     const total = uncheckedMatches.length + checkedMatches.length;
@@ -45845,10 +46004,11 @@ function createQuestionLabelTruncatorHook() {
 // src/hooks/stop-continuation-guard/hook.ts
 init_logger();
 var HOOK_NAME8 = "stop-continuation-guard";
-function createStopContinuationGuardHook(_ctx) {
+function createStopContinuationGuardHook(ctx) {
   const stoppedSessions = new Set;
   const stop = (sessionID) => {
     stoppedSessions.add(sessionID);
+    setContinuationMarkerSource(ctx.directory, sessionID, "stop", "stopped", "continuation stopped");
     log(`[${HOOK_NAME8}] Continuation stopped for session`, { sessionID });
   };
   const isStopped = (sessionID) => {
@@ -45856,6 +46016,7 @@ function createStopContinuationGuardHook(_ctx) {
   };
   const clear = (sessionID) => {
     stoppedSessions.delete(sessionID);
+    setContinuationMarkerSource(ctx.directory, sessionID, "stop", "idle");
     log(`[${HOOK_NAME8}] Continuation guard cleared for session`, { sessionID });
   };
   const event = async ({
@@ -45866,6 +46027,7 @@ function createStopContinuationGuardHook(_ctx) {
       const sessionInfo = props?.info;
       if (sessionInfo?.id) {
         clear(sessionInfo.id);
+        clearContinuationMarker(ctx.directory, sessionInfo.id);
         log(`[${HOOK_NAME8}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
       }
     }
@@ -46356,8 +46518,8 @@ function createTasksTodowriteDisablerHook(config2) {
   };
 }
 // src/hooks/write-existing-file-guard/hook.ts
-import { existsSync as existsSync46 } from "fs";
-import { resolve as resolve7, isAbsolute as isAbsolute5, join as join57, normalize, sep } from "path";
+import { existsSync as existsSync47 } from "fs";
+import { resolve as resolve7, isAbsolute as isAbsolute5, join as join58, normalize, sep } from "path";
 function createWriteExistingFileGuardHook(ctx) {
   return {
     "tool.execute.before": async (input, output) => {
@@ -46371,8 +46533,8 @@ function createWriteExistingFileGuardHook(ctx) {
         return;
       }
       const resolvedPath = normalize(isAbsolute5(filePath) ? filePath : resolve7(ctx.directory, filePath));
-      if (existsSync46(resolvedPath)) {
-        const sisyphusRoot = join57(ctx.directory, ".sisyphus") + sep;
+      if (existsSync47(resolvedPath)) {
+        const sisyphusRoot = join58(ctx.directory, ".sisyphus") + sep;
         const isSisyphusMarkdown = resolvedPath.startsWith(sisyphusRoot) && resolvedPath.endsWith(".md");
         if (isSisyphusMarkdown) {
           log("[write-existing-file-guard] Allowing .sisyphus/*.md overwrite", {
@@ -47007,13 +47169,13 @@ var DEFAULT_MAX_REFERENCES = 200;
 var DEFAULT_MAX_SYMBOLS = 200;
 var DEFAULT_MAX_DIAGNOSTICS = 200;
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync47, readFileSync as readFileSync35 } from "fs";
-import { join as join58 } from "path";
+import { existsSync as existsSync48, readFileSync as readFileSync36 } from "fs";
+import { join as join59 } from "path";
 function loadJsonFile(path10) {
-  if (!existsSync47(path10))
+  if (!existsSync48(path10))
     return null;
   try {
-    return parseJsonc(readFileSync35(path10, "utf-8"));
+    return parseJsonc(readFileSync36(path10, "utf-8"));
   } catch {
     return null;
   }
@@ -47022,9 +47184,9 @@ function getConfigPaths3() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectConfigFile(join58(cwd, ".opencode", "oh-my-opencode")).path,
-    user: detectConfigFile(join58(configDir, "oh-my-opencode")).path,
-    opencode: detectConfigFile(join58(configDir, "opencode")).path
+    project: detectConfigFile(join59(cwd, ".opencode", "oh-my-opencode")).path,
+    user: detectConfigFile(join59(configDir, "oh-my-opencode")).path,
+    opencode: detectConfigFile(join59(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -47093,14 +47255,14 @@ function getMergedServers() {
 }
 
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync48 } from "fs";
-import { join as join59 } from "path";
+import { existsSync as existsSync49 } from "fs";
+import { join as join60 } from "path";
 function isServerInstalled(command) {
   if (command.length === 0)
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync48(cmd))
+    if (existsSync49(cmd))
       return true;
   }
   const isWindows2 = process.platform === "win32";
@@ -47122,23 +47284,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync48(join59(p, cmd + suffix))) {
+      if (existsSync49(join60(p, cmd + suffix))) {
         return true;
       }
     }
   }
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join59(getDataDir(), "opencode");
+  const dataDir = join60(getDataDir(), "opencode");
   const additionalBases = [
-    join59(cwd, "node_modules", ".bin"),
-    join59(configDir, "bin"),
-    join59(configDir, "node_modules", ".bin"),
-    join59(dataDir, "bin")
+    join60(cwd, "node_modules", ".bin"),
+    join60(configDir, "bin"),
+    join60(configDir, "node_modules", ".bin"),
+    join60(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync48(join59(base, cmd + suffix))) {
+      if (existsSync49(join60(base, cmd + suffix))) {
         return true;
       }
     }
@@ -47196,13 +47358,13 @@ function getLanguageId(ext) {
 init_logger();
 var {spawn: bunSpawn } = globalThis.Bun;
 import { spawn as nodeSpawn } from "child_process";
-import { existsSync as existsSync49, statSync as statSync6 } from "fs";
+import { existsSync as existsSync50, statSync as statSync6 } from "fs";
 function shouldUseNodeSpawn() {
   return process.platform === "win32";
 }
 function validateCwd(cwd) {
   try {
-    if (!existsSync49(cwd)) {
+    if (!existsSync50(cwd)) {
       return { valid: false, error: `Working directory does not exist: ${cwd}` };
     }
     const stats = statSync6(cwd);
@@ -47383,7 +47545,7 @@ async function cleanupTempDirectoryLspClients(clients) {
 }
 
 // src/tools/lsp/lsp-client.ts
-import { readFileSync as readFileSync36 } from "fs";
+import { readFileSync as readFileSync37 } from "fs";
 import { extname as extname2, resolve as resolve8 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
@@ -47647,7 +47809,7 @@ class LSPClient extends LSPClientConnection {
   async openFile(filePath) {
     const absPath = resolve8(filePath);
     const uri = pathToFileURL2(absPath).href;
-    const text = readFileSync36(absPath, "utf-8");
+    const text = readFileSync37(absPath, "utf-8");
     if (!this.openedFiles.has(absPath)) {
       const ext = extname2(absPath);
       const languageId = getLanguageId(ext);
@@ -47922,17 +48084,17 @@ var lspManager = LSPServerManager.getInstance();
 // src/tools/lsp/lsp-client-wrapper.ts
 import { extname as extname3, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { existsSync as existsSync50 } from "fs";
+import { existsSync as existsSync51 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve9(filePath);
-  if (!existsSync50(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync51(dir) || !__require("fs").statSync(dir).isDirectory()) {
     dir = __require("path").dirname(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   let prevDir = "";
   while (dir !== prevDir) {
     for (const marker of markers) {
-      if (existsSync50(__require("path").join(dir, marker))) {
+      if (existsSync51(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -48107,10 +48269,10 @@ function formatApplyResult(result) {
 `);
 }
 // src/tools/lsp/workspace-edit.ts
-import { readFileSync as readFileSync37, writeFileSync as writeFileSync17 } from "fs";
+import { readFileSync as readFileSync38, writeFileSync as writeFileSync18 } from "fs";
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync37(filePath, "utf-8");
+    let content = readFileSync38(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -48135,7 +48297,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync17(filePath, lines.join(`
+    writeFileSync18(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -48166,7 +48328,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = uriToPath(change.uri);
-            writeFileSync17(filePath, "", "utf-8");
+            writeFileSync18(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -48176,8 +48338,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync37(oldPath, "utf-8");
-            writeFileSync17(newPath, content, "utf-8");
+            const content = readFileSync38(oldPath, "utf-8");
+            writeFileSync18(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -48458,12 +48620,12 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/sg-cli-path.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname15, join as join61 } from "path";
-import { existsSync as existsSync52, statSync as statSync7 } from "fs";
+import { dirname as dirname15, join as join62 } from "path";
+import { existsSync as existsSync53, statSync as statSync7 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
-import { existsSync as existsSync51 } from "fs";
-import { join as join60 } from "path";
+import { existsSync as existsSync52 } from "fs";
+import { join as join61 } from "path";
 import { homedir as homedir12 } from "os";
 import { createRequire as createRequire3 } from "module";
 init_logger();
@@ -48490,12 +48652,12 @@ var PLATFORM_MAP2 = {
 function getCacheDir4() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join60(homedir12(), "AppData", "Local");
-    return join60(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join61(homedir12(), "AppData", "Local");
+    return join61(base2, "oh-my-opencode", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join60(homedir12(), ".cache");
-  return join60(base, "oh-my-opencode", "bin");
+  const base = xdgCache || join61(homedir12(), ".cache");
+  return join61(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
@@ -48512,8 +48674,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir4();
   const binaryName = getBinaryName3();
-  const binaryPath = join60(cacheDir, binaryName);
-  if (existsSync51(binaryPath)) {
+  const binaryPath = join61(cacheDir, binaryName);
+  if (existsSync52(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os6 } = platformInfo;
@@ -48521,7 +48683,7 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    const archivePath = join60(cacheDir, assetName);
+    const archivePath = join61(cacheDir, assetName);
     ensureCacheDir(cacheDir);
     await downloadArchive(downloadUrl, archivePath);
     await extractZipArchive(archivePath, cacheDir);
@@ -48575,8 +48737,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPackageJsonPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDirectory = dirname15(cliPackageJsonPath);
-    const sgPath = join61(cliDirectory, binaryName);
-    if (existsSync52(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join62(cliDirectory, binaryName);
+    if (existsSync53(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -48587,8 +48749,8 @@ function findSgCliPathSync() {
       const packageJsonPath = require2.resolve(`${platformPackage}/package.json`);
       const packageDirectory = dirname15(packageJsonPath);
       const astGrepBinaryName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join61(packageDirectory, astGrepBinaryName);
-      if (existsSync52(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join62(packageDirectory, astGrepBinaryName);
+      if (existsSync53(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -48596,7 +48758,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path10 of homebrewPaths) {
-      if (existsSync52(path10) && isValidBinary(path10)) {
+      if (existsSync53(path10) && isValidBinary(path10)) {
         return path10;
       }
     }
@@ -48620,14 +48782,14 @@ function setSgCliPath(path10) {
 }
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn10 } = globalThis.Bun;
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync55 } from "fs";
 
 // src/tools/ast-grep/cli-binary-path-resolution.ts
-import { existsSync as existsSync53 } from "fs";
+import { existsSync as existsSync54 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise3 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync53(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync54(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise3) {
@@ -48635,7 +48797,7 @@ async function getAstGrepPath() {
   }
   initPromise3 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync53(syncPath)) {
+    if (syncPath && existsSync54(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -48734,7 +48896,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!cliPath || !existsSync54(cliPath)) {
+  if (!cliPath || !existsSync55(cliPath)) {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -48985,19 +49147,19 @@ ${hint}`;
 var {spawn: spawn11 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync56 } from "fs";
-import { join as join63, dirname as dirname16 } from "path";
+import { existsSync as existsSync57 } from "fs";
+import { join as join64, dirname as dirname16 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync55, readdirSync as readdirSync14 } from "fs";
-import { join as join62 } from "path";
+import { existsSync as existsSync56, readdirSync as readdirSync14 } from "fs";
+import { join as join63 } from "path";
 function findFileRecursive(dir, filename) {
   try {
     const entries = readdirSync14(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        return join62(entry.parentPath ?? dir, entry.name);
+        return join63(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -49018,11 +49180,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join62(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join63(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join62(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join63(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 async function extractTarGz2(archivePath, destDir) {
   const platformKey = getPlatformKey();
@@ -49039,7 +49201,7 @@ async function extractZip2(archivePath, destDir) {
   const binaryName = process.platform === "win32" ? "rg.exe" : "rg";
   const foundPath = findFileRecursive(destDir, binaryName);
   if (foundPath) {
-    const destPath = join62(destDir, binaryName);
+    const destPath = join63(destDir, binaryName);
     if (foundPath !== destPath) {
       const { renameSync } = await import("fs");
       renameSync(foundPath, destPath);
@@ -49054,13 +49216,13 @@ async function downloadAndInstallRipgrep() {
   }
   const installDir = getInstallDir();
   const rgPath = getRgPath();
-  if (existsSync55(rgPath)) {
+  if (existsSync56(rgPath)) {
     return rgPath;
   }
   ensureCacheDir(installDir);
   const filename = `ripgrep-${RG_VERSION}-${config3.platform}.${config3.extension}`;
   const url2 = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${filename}`;
-  const archivePath = join62(installDir, filename);
+  const archivePath = join63(installDir, filename);
   try {
     await downloadArchive(url2, archivePath);
     if (config3.extension === "tar.gz") {
@@ -49069,7 +49231,7 @@ async function downloadAndInstallRipgrep() {
       await extractZip2(archivePath, installDir);
     }
     ensureExecutable(rgPath);
-    if (!existsSync55(rgPath)) {
+    if (!existsSync56(rgPath)) {
       throw new Error("ripgrep binary not found after extraction");
     }
     return rgPath;
@@ -49081,7 +49243,7 @@ async function downloadAndInstallRipgrep() {
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync55(rgPath) ? rgPath : null;
+  return existsSync56(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -49105,14 +49267,14 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join63(getDataDir(), "opencode", "bin", rgName),
-    join63(execDir, rgName),
-    join63(execDir, "bin", rgName),
-    join63(execDir, "..", "bin", rgName),
-    join63(execDir, "..", "libexec", rgName)
+    join64(getDataDir(), "opencode", "bin", rgName),
+    join64(execDir, rgName),
+    join64(execDir, "bin", rgName),
+    join64(execDir, "..", "bin", rgName),
+    join64(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync56(candidate)) {
+    if (existsSync57(candidate)) {
       return candidate;
     }
   }
@@ -49578,20 +49740,20 @@ function createGlobTools(ctx) {
   return { glob };
 }
 // src/tools/slashcommand/command-discovery.ts
-import { existsSync as existsSync57, readdirSync as readdirSync15, readFileSync as readFileSync38 } from "fs";
-import { basename as basename4, join as join64 } from "path";
+import { existsSync as existsSync58, readdirSync as readdirSync15, readFileSync as readFileSync39 } from "fs";
+import { basename as basename4, join as join65 } from "path";
 function discoverCommandsFromDir2(commandsDir, scope) {
-  if (!existsSync57(commandsDir))
+  if (!existsSync58(commandsDir))
     return [];
   const entries = readdirSync15(commandsDir, { withFileTypes: true });
   const commands2 = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join64(commandsDir, entry.name);
+    const commandPath = join65(commandsDir, entry.name);
     const commandName = basename4(entry.name, ".md");
     try {
-      const content = readFileSync38(commandPath, "utf-8");
+      const content = readFileSync39(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -49617,10 +49779,10 @@ function discoverCommandsFromDir2(commandsDir, scope) {
 }
 function discoverCommandsSync(directory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const userCommandsDir = join64(getClaudeConfigDir(), "commands");
-  const projectCommandsDir = join64(directory ?? process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join64(configDir, "command");
-  const opencodeProjectDir = join64(directory ?? process.cwd(), ".opencode", "command");
+  const userCommandsDir = join65(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join65(directory ?? process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join65(configDir, "command");
+  const opencodeProjectDir = join65(directory ?? process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir2(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir2(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir2(projectCommandsDir, "project");
@@ -49828,9 +49990,9 @@ Try a different name.`;
 }
 var slashcommand = createSlashcommandTool();
 // src/tools/session-manager/constants.ts
-import { join as join65 } from "path";
-var TODO_DIR2 = join65(getClaudeConfigDir(), "todos");
-var TRANSCRIPT_DIR2 = join65(getClaudeConfigDir(), "transcripts");
+import { join as join66 } from "path";
+var TODO_DIR2 = join66(getClaudeConfigDir(), "todos");
+var TRANSCRIPT_DIR2 = join66(getClaudeConfigDir(), "transcripts");
 var SESSION_LIST_DESCRIPTION = `List all OpenCode sessions with optional filtering.
 
 Returns a list of available session IDs with metadata including message count, date range, and agents used.
@@ -49903,9 +50065,9 @@ Has Todos: Yes (12 items, 8 completed)
 Has Transcript: Yes (234 entries)`;
 
 // src/tools/session-manager/storage.ts
-import { existsSync as existsSync58 } from "fs";
+import { existsSync as existsSync59 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { join as join66 } from "path";
+import { join as join67 } from "path";
 var sdkClient = null;
 function setStorageClient(client2) {
   sdkClient = client2;
@@ -49924,7 +50086,7 @@ async function getMainSessions(options) {
       return [];
     }
   }
-  if (!existsSync58(SESSION_STORAGE))
+  if (!existsSync59(SESSION_STORAGE))
     return [];
   const sessions = [];
   try {
@@ -49932,13 +50094,13 @@ async function getMainSessions(options) {
     for (const projectDir of projectDirs) {
       if (!projectDir.isDirectory())
         continue;
-      const projectPath = join66(SESSION_STORAGE, projectDir.name);
+      const projectPath = join67(SESSION_STORAGE, projectDir.name);
       const sessionFiles = await readdir(projectPath);
       for (const file2 of sessionFiles) {
         if (!file2.endsWith(".json"))
           continue;
         try {
-          const content = await readFile(join66(projectPath, file2), "utf-8");
+          const content = await readFile(join67(projectPath, file2), "utf-8");
           const meta = JSON.parse(content);
           if (meta.parentID)
             continue;
@@ -49965,7 +50127,7 @@ async function getAllSessions() {
       return [];
     }
   }
-  if (!existsSync58(MESSAGE_STORAGE))
+  if (!existsSync59(MESSAGE_STORAGE))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -49973,7 +50135,7 @@ async function getAllSessions() {
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const sessionPath = join66(dir, entry.name);
+          const sessionPath = join67(dir, entry.name);
           const files = await readdir(sessionPath);
           if (files.some((f) => f.endsWith(".json"))) {
             sessions.push(entry.name);
@@ -50034,7 +50196,7 @@ async function readSessionMessages(sessionID) {
     }
   }
   const messageDir = getMessageDir(sessionID);
-  if (!messageDir || !existsSync58(messageDir))
+  if (!messageDir || !existsSync59(messageDir))
     return [];
   const messages = [];
   try {
@@ -50043,7 +50205,7 @@ async function readSessionMessages(sessionID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join66(messageDir, file2), "utf-8");
+        const content = await readFile(join67(messageDir, file2), "utf-8");
         const meta = JSON.parse(content);
         const parts = await readParts2(meta.id);
         messages.push({
@@ -50069,8 +50231,8 @@ async function readSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join66(PART_STORAGE, messageID);
-  if (!existsSync58(partDir))
+  const partDir = join67(PART_STORAGE, messageID);
+  if (!existsSync59(partDir))
     return [];
   const parts = [];
   try {
@@ -50079,7 +50241,7 @@ async function readParts2(messageID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join66(partDir, file2), "utf-8");
+        const content = await readFile(join67(partDir, file2), "utf-8");
         parts.push(JSON.parse(content));
       } catch {
         continue;
@@ -50105,14 +50267,14 @@ async function readSessionTodos(sessionID) {
       return [];
     }
   }
-  if (!existsSync58(TODO_DIR2))
+  if (!existsSync59(TODO_DIR2))
     return [];
   try {
     const allFiles = await readdir(TODO_DIR2);
     const todoFiles = allFiles.filter((f) => f.includes(sessionID) && f.endsWith(".json"));
     for (const file2 of todoFiles) {
       try {
-        const content = await readFile(join66(TODO_DIR2, file2), "utf-8");
+        const content = await readFile(join67(TODO_DIR2, file2), "utf-8");
         const data = JSON.parse(content);
         if (Array.isArray(data)) {
           return data.map((item) => ({
@@ -50132,10 +50294,10 @@ async function readSessionTodos(sessionID) {
   return [];
 }
 async function readSessionTranscript(sessionID) {
-  if (!existsSync58(TRANSCRIPT_DIR2))
+  if (!existsSync59(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join66(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync58(transcriptFile))
+  const transcriptFile = join67(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  if (!existsSync59(transcriptFile))
     return 0;
   try {
     const content = await readFile(transcriptFile, "utf-8");
@@ -53731,7 +53893,7 @@ Prompts MUST be in English.`;
 // src/tools/delegate-task/index.ts
 init_constants();
 // src/tools/task/task-create.ts
-import { join as join68 } from "path";
+import { join as join69 } from "path";
 
 // src/tools/task/types.ts
 var TaskStatusSchema = exports_external.enum(["pending", "in_progress", "completed", "deleted"]);
@@ -53785,18 +53947,18 @@ var TaskDeleteInputSchema = exports_external.object({
 });
 
 // src/features/claude-tasks/storage.ts
-import { join as join67, dirname as dirname19, basename as basename6, isAbsolute as isAbsolute6 } from "path";
-import { existsSync as existsSync59, mkdirSync as mkdirSync13, readFileSync as readFileSync39, writeFileSync as writeFileSync18, renameSync, unlinkSync as unlinkSync9, readdirSync as readdirSync16 } from "fs";
+import { join as join68, dirname as dirname19, basename as basename6, isAbsolute as isAbsolute6 } from "path";
+import { existsSync as existsSync60, mkdirSync as mkdirSync14, readFileSync as readFileSync40, writeFileSync as writeFileSync19, renameSync, unlinkSync as unlinkSync9, readdirSync as readdirSync16 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 function getTaskDir(config3 = {}) {
   const tasksConfig = config3.sisyphus?.tasks;
   const storagePath = tasksConfig?.storage_path;
   if (storagePath) {
-    return isAbsolute6(storagePath) ? storagePath : join67(process.cwd(), storagePath);
+    return isAbsolute6(storagePath) ? storagePath : join68(process.cwd(), storagePath);
   }
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   const listId = resolveTaskListId(config3);
-  return join67(configDir, "tasks", listId);
+  return join68(configDir, "tasks", listId);
 }
 function sanitizePathSegment(value) {
   return value.replace(/[^a-zA-Z0-9_-]/g, "-") || "default";
@@ -53814,16 +53976,16 @@ function resolveTaskListId(config3 = {}) {
   return sanitizePathSegment(basename6(process.cwd()));
 }
 function ensureDir(dirPath) {
-  if (!existsSync59(dirPath)) {
-    mkdirSync13(dirPath, { recursive: true });
+  if (!existsSync60(dirPath)) {
+    mkdirSync14(dirPath, { recursive: true });
   }
 }
 function readJsonSafe(filePath, schema2) {
   try {
-    if (!existsSync59(filePath)) {
+    if (!existsSync60(filePath)) {
       return null;
     }
-    const content = readFileSync39(filePath, "utf-8");
+    const content = readFileSync40(filePath, "utf-8");
     const parsed = JSON.parse(content);
     const result = schema2.safeParse(parsed);
     if (!result.success) {
@@ -53839,11 +54001,11 @@ function writeJsonAtomic(filePath, data) {
   ensureDir(dir);
   const tempPath = `${filePath}.tmp.${Date.now()}`;
   try {
-    writeFileSync18(tempPath, JSON.stringify(data, null, 2), "utf-8");
+    writeFileSync19(tempPath, JSON.stringify(data, null, 2), "utf-8");
     renameSync(tempPath, filePath);
   } catch (error45) {
     try {
-      if (existsSync59(tempPath)) {
+      if (existsSync60(tempPath)) {
         unlinkSync9(tempPath);
       }
     } catch {}
@@ -53855,17 +54017,17 @@ function generateTaskId() {
   return `T-${randomUUID2()}`;
 }
 function acquireLock(dirPath) {
-  const lockPath = join67(dirPath, ".lock");
+  const lockPath = join68(dirPath, ".lock");
   const lockId = randomUUID2();
   const createLock = (timestamp2) => {
-    writeFileSync18(lockPath, JSON.stringify({ id: lockId, timestamp: timestamp2 }), {
+    writeFileSync19(lockPath, JSON.stringify({ id: lockId, timestamp: timestamp2 }), {
       encoding: "utf-8",
       flag: "wx"
     });
   };
   const isStale = () => {
     try {
-      const lockContent = readFileSync39(lockPath, "utf-8");
+      const lockContent = readFileSync40(lockPath, "utf-8");
       const lockData = JSON.parse(lockContent);
       const lockAge = Date.now() - lockData.timestamp;
       return lockAge > STALE_LOCK_THRESHOLD_MS;
@@ -53903,9 +54065,9 @@ function acquireLock(dirPath) {
     acquired: true,
     release: () => {
       try {
-        if (!existsSync59(lockPath))
+        if (!existsSync60(lockPath))
           return;
-        const lockContent = readFileSync39(lockPath, "utf-8");
+        const lockContent = readFileSync40(lockPath, "utf-8");
         const lockData = JSON.parse(lockContent);
         if (lockData.id !== lockId)
           return;
@@ -54068,7 +54230,7 @@ async function handleCreate(args, config3, ctx, context) {
         threadID: context.sessionID
       };
       const validatedTask = TaskObjectSchema.parse(task);
-      writeJsonAtomic(join68(taskDir, `${taskId}.json`), validatedTask);
+      writeJsonAtomic(join69(taskDir, `${taskId}.json`), validatedTask);
       await syncTaskTodoUpdate(ctx, validatedTask, context.sessionID);
       return JSON.stringify({
         task: {
@@ -54090,7 +54252,7 @@ async function handleCreate(args, config3, ctx, context) {
   }
 }
 // src/tools/task/task-get.ts
-import { join as join69 } from "path";
+import { join as join70 } from "path";
 var TASK_ID_PATTERN = /^T-[A-Za-z0-9-]+$/;
 function parseTaskId(id) {
   if (!TASK_ID_PATTERN.test(id))
@@ -54115,7 +54277,7 @@ Returns null if the task does not exist or the file is invalid.`,
           return JSON.stringify({ error: "invalid_task_id" });
         }
         const taskDir = getTaskDir(config3);
-        const taskPath = join69(taskDir, `${taskId}.json`);
+        const taskPath = join70(taskDir, `${taskId}.json`);
         const task = readJsonSafe(taskPath, TaskObjectSchema);
         return JSON.stringify({ task: task ?? null });
       } catch (error45) {
@@ -54128,8 +54290,8 @@ Returns null if the task does not exist or the file is invalid.`,
   });
 }
 // src/tools/task/task-list.ts
-import { join as join70 } from "path";
-import { existsSync as existsSync60, readdirSync as readdirSync17 } from "fs";
+import { join as join71 } from "path";
+import { existsSync as existsSync61, readdirSync as readdirSync17 } from "fs";
 function createTaskList(config3) {
   return tool({
     description: `List all active tasks with summary information.
@@ -54140,7 +54302,7 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
     args: {},
     execute: async () => {
       const taskDir = getTaskDir(config3);
-      if (!existsSync60(taskDir)) {
+      if (!existsSync61(taskDir)) {
         return JSON.stringify({ tasks: [] });
       }
       const files = readdirSync17(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-")).map((f) => f.replace(".json", ""));
@@ -54149,7 +54311,7 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
       }
       const allTasks = [];
       for (const fileId of files) {
-        const task = readJsonSafe(join70(taskDir, `${fileId}.json`), TaskObjectSchema);
+        const task = readJsonSafe(join71(taskDir, `${fileId}.json`), TaskObjectSchema);
         if (task) {
           allTasks.push(task);
         }
@@ -54176,7 +54338,7 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
   });
 }
 // src/tools/task/task-update.ts
-import { join as join71 } from "path";
+import { join as join72 } from "path";
 var TASK_ID_PATTERN2 = /^T-[A-Za-z0-9-]+$/;
 function parseTaskId2(id) {
   if (!TASK_ID_PATTERN2.test(id))
@@ -54224,7 +54386,7 @@ async function handleUpdate(args, config3, ctx, context) {
       return JSON.stringify({ error: "task_lock_unavailable" });
     }
     try {
-      const taskPath = join71(taskDir, `${taskId}.json`);
+      const taskPath = join72(taskDir, `${taskId}.json`);
       const task = readJsonSafe(taskPath, TaskObjectSchema);
       if (!task) {
         return JSON.stringify({ error: "task_not_found" });
@@ -54544,10 +54706,12 @@ function createSessionHooks(args) {
     checkSessionExists: async (sessionId) => await sessionExists(sessionId)
   })) : null;
   const editErrorRecovery = isHookEnabled("edit-error-recovery") ? safeHook("edit-error-recovery", () => createEditErrorRecoveryHook(ctx)) : null;
+  const jsonErrorRecovery = isHookEnabled("json-error-recovery") ? safeHook("json-error-recovery", () => createJsonErrorRecoveryHook(ctx)) : null;
   const delegateTaskRetry = isHookEnabled("delegate-task-retry") ? safeHook("delegate-task-retry", () => createDelegateTaskRetryHook(ctx)) : null;
   const startWork = isHookEnabled("start-work") ? safeHook("start-work", () => createStartWorkHook(ctx)) : null;
   const prometheusMdOnly = isHookEnabled("prometheus-md-only") ? safeHook("prometheus-md-only", () => createPrometheusMdOnlyHook(ctx)) : null;
   const sisyphusJuniorNotepad = isHookEnabled("sisyphus-junior-notepad") ? safeHook("sisyphus-junior-notepad", () => createSisyphusJuniorNotepadHook(ctx)) : null;
+  const sisyphusGptHephaestusReminder = isHookEnabled("sisyphus-gpt-hephaestus-reminder") ? safeHook("sisyphus-gpt-hephaestus-reminder", () => createSisyphusGptHephaestusReminderHook(ctx)) : null;
   const questionLabelTruncator = createQuestionLabelTruncatorHook();
   const taskResumeInfo = createTaskResumeInfoHook();
   const anthropicEffort = isHookEnabled("anthropic-effort") ? safeHook("anthropic-effort", () => createAnthropicEffortHook()) : null;
@@ -54564,10 +54728,12 @@ function createSessionHooks(args) {
     interactiveBashSession,
     ralphLoop,
     editErrorRecovery,
+    jsonErrorRecovery,
     delegateTaskRetry,
     startWork,
     prometheusMdOnly,
     sisyphusJuniorNotepad,
+    sisyphusGptHephaestusReminder,
     questionLabelTruncator,
     taskResumeInfo,
     anthropicEffort
@@ -55106,8 +55272,8 @@ var POLLING_INTERVAL_MS = 3000;
 var TASK_CLEANUP_DELAY_MS = 10 * 60 * 1000;
 
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync61, readFileSync as readFileSync40, readdirSync as readdirSync18 } from "fs";
-import { join as join72 } from "path";
+import { existsSync as existsSync62, readFileSync as readFileSync41, readdirSync as readdirSync18 } from "fs";
+import { join as join73 } from "path";
 
 class BackgroundManager {
   static cleanupManagers = new Set;
@@ -56396,14 +56562,14 @@ function registerProcessSignal(signal, handler, exitAfter) {
   return listener;
 }
 function getMessageDir2(sessionID) {
-  if (!existsSync61(MESSAGE_STORAGE))
+  if (!existsSync62(MESSAGE_STORAGE))
     return null;
-  const directPath = join72(MESSAGE_STORAGE, sessionID);
-  if (existsSync61(directPath))
+  const directPath = join73(MESSAGE_STORAGE, sessionID);
+  if (existsSync62(directPath))
     return directPath;
   for (const dir of readdirSync18(MESSAGE_STORAGE)) {
-    const sessionPath = join72(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync61(sessionPath))
+    const sessionPath = join73(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync62(sessionPath))
       return sessionPath;
   }
   return null;
@@ -56424,7 +56590,7 @@ function findNearestMessageExcludingCompaction(messageDir) {
     const files = readdirSync18(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
     for (const file2 of files) {
       try {
-        const content = readFileSync40(join72(messageDir, file2), "utf-8");
+        const content = readFileSync41(join73(messageDir, file2), "utf-8");
         const parsed = JSON.parse(content);
         if (hasFullAgentAndModel(parsed)) {
           return parsed;
@@ -56435,7 +56601,7 @@ function findNearestMessageExcludingCompaction(messageDir) {
     }
     for (const file2 of files) {
       try {
-        const content = readFileSync40(join72(messageDir, file2), "utf-8");
+        const content = readFileSync41(join73(messageDir, file2), "utf-8");
         const parsed = JSON.parse(content);
         if (hasPartialAgentOrModel(parsed)) {
           return parsed;
@@ -60434,11 +60600,11 @@ class StreamableHTTPClientTransport {
 }
 
 // src/features/mcp-oauth/storage.ts
-import { chmodSync as chmodSync2, existsSync as existsSync62, mkdirSync as mkdirSync14, readFileSync as readFileSync41, unlinkSync as unlinkSync10, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname20, join as join73 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync63, mkdirSync as mkdirSync15, readFileSync as readFileSync42, unlinkSync as unlinkSync10, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname20, join as join74 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join73(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join74(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -60475,11 +60641,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync62(filePath)) {
+  if (!existsSync63(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync41(filePath, "utf-8");
+    const content = readFileSync42(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -60489,10 +60655,10 @@ function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
     const dir = dirname20(filePath);
-    if (!existsSync62(dir)) {
-      mkdirSync14(dir, { recursive: true });
+    if (!existsSync63(dir)) {
+      mkdirSync15(dir, { recursive: true });
     }
-    writeFileSync19(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
+    writeFileSync20(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
     chmodSync2(filePath, 384);
     return true;
   } catch {
@@ -60658,29 +60824,9 @@ function isRecord4(value) {
 
 // src/features/mcp-oauth/callback-server.ts
 var DEFAULT_PORT = 19877;
-var MAX_PORT_ATTEMPTS = 20;
 var TIMEOUT_MS = 5 * 60 * 1000;
-async function isPortAvailable(port) {
-  try {
-    const server = Bun.serve({
-      port,
-      hostname: "127.0.0.1",
-      fetch: () => new Response
-    });
-    server.stop(true);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function findAvailablePort(startPort = DEFAULT_PORT) {
-  for (let attempt = 0;attempt < MAX_PORT_ATTEMPTS; attempt++) {
-    const port = startPort + attempt;
-    if (await isPortAvailable(port)) {
-      return port;
-    }
-  }
-  throw new Error(`No available port found in range ${startPort}-${startPort + MAX_PORT_ATTEMPTS - 1}`);
+async function findAvailablePort2(startPort = DEFAULT_PORT) {
+  return findAvailablePort(startPort);
 }
 
 // src/features/mcp-oauth/oauth-authorization-flow.ts
@@ -60835,7 +60981,7 @@ class McpOAuthProvider {
       throw new Error("No client information available. Run login() or register a client first.");
     }
     if (this.callbackPort === null) {
-      this.callbackPort = await findAvailablePort();
+      this.callbackPort = await findAvailablePort2();
     }
     const result = await runAuthorizationCodeRedirect({
       authorizationEndpoint: metadata.authorizationEndpoint,
@@ -65699,7 +65845,7 @@ function buildAgent(source, model, categories, gitMasterConfig, browserProvider,
 }
 
 // src/agents/builtin-agents/resolve-file-uri.ts
-import { existsSync as existsSync63, readFileSync as readFileSync42 } from "fs";
+import { existsSync as existsSync64, readFileSync as readFileSync43 } from "fs";
 import { homedir as homedir13 } from "os";
 import { isAbsolute as isAbsolute7, resolve as resolve10 } from "path";
 function resolvePromptAppend(promptAppend, configDir) {
@@ -65714,11 +65860,11 @@ function resolvePromptAppend(promptAppend, configDir) {
   } catch {
     return `[WARNING: Malformed file URI (invalid percent-encoding): ${promptAppend}]`;
   }
-  if (!existsSync63(filePath)) {
+  if (!existsSync64(filePath)) {
     return `[WARNING: Could not resolve file URI: ${promptAppend}]`;
   }
   try {
-    return readFileSync42(filePath, "utf8");
+    return readFileSync43(filePath, "utf8");
   } catch {
     return `[WARNING: Could not read file: ${promptAppend}]`;
   }
@@ -66360,47 +66506,71 @@ unblocking maximum parallelism in subsequent waves.
 
 **The plan can have 50+ TODOs. That's OK. ONE PLAN.**
 
-### 6.1 SINGLE ATOMIC WRITE (CRITICAL - Prevents Content Loss)
+### 6.1 INCREMENTAL WRITE PROTOCOL (CRITICAL - Prevents Output Limit Stalls)
 
 <write_protocol>
-**The Write tool OVERWRITES files. It does NOT append.**
+**Write OVERWRITES. Never call Write twice on the same file.**
 
-**MANDATORY PROTOCOL:**
-1. **Prepare ENTIRE plan content in memory FIRST**
-2. **Write ONCE with complete content**
-3. **NEVER split into multiple Write calls**
+Plans with many tasks will exceed your output token limit if you try to generate everything at once.
+Split into: **one Write** (skeleton) + **multiple Edits** (tasks in batches).
 
-**IF plan is too large for single output:**
-1. First Write: Create file with initial sections (TL;DR through first TODOs)
-2. Subsequent: Use **Edit tool** to APPEND remaining sections
-   - Target the END of the file
-   - Edit replaces text, so include last line + new content
+**Step 1 \u2014 Write skeleton (all sections EXCEPT individual task details):**
 
-**FORBIDDEN (causes content loss):**
 \`\`\`
-\u274C Write(".sisyphus/plans/x.md", "# Part 1...")  
-\u274C Write(".sisyphus/plans/x.md", "# Part 2...")  // Part 1 is GONE!
-\`\`\`
-
-**CORRECT (preserves content):**
-\`\`\`
-\u2705 Write(".sisyphus/plans/x.md", "# Complete plan content...")  // Single write
+Write(".sisyphus/plans/{name}.md", content=\`
+# {Plan Title}
 
-// OR if too large:
-\u2705 Write(".sisyphus/plans/x.md", "# Plan
 ## TL;DR
-...")  // First chunk
-\u2705 Edit(".sisyphus/plans/x.md", oldString="---
-## Success Criteria", newString="---
-## More TODOs
+> ...
+
+## Context
+...
+
+## Work Objectives
+...
+
+## Verification Strategy
 ...
+
+## Execution Strategy
+...
+
 ---
-## Success Criteria")  // Append via Edit
+
+## TODOs
+
+---
+
+## Final Verification Wave
+...
+
+## Commit Strategy
+...
+
+## Success Criteria
+...
+\`)
 \`\`\`
 
-**SELF-CHECK before Write:**
-- [ ] Is this the FIRST write to this file? \u2192 Write is OK
-- [ ] File already exists with my content? \u2192 Use Edit to append, NOT Write
+**Step 2 \u2014 Edit-append tasks in batches of 2-4:**
+
+Use Edit to insert each batch of tasks before the Final Verification section:
+
+\`\`\`
+Edit(".sisyphus/plans/{name}.md",
+  oldString="---\\n\\n## Final Verification Wave",
+  newString="- [ ] 1. Task Title\\n\\n  **What to do**: ...\\n  **QA Scenarios**: ...\\n\\n- [ ] 2. Task Title\\n\\n  **What to do**: ...\\n  **QA Scenarios**: ...\\n\\n---\\n\\n## Final Verification Wave")
+\`\`\`
+
+Repeat until all tasks are written. 2-4 tasks per Edit call balances speed and output limits.
+
+**Step 3 \u2014 Verify completeness:**
+
+After all Edits, Read the plan file to confirm all tasks are present and no content was lost.
+
+**FORBIDDEN:**
+- \`Write()\` twice to the same file \u2014 second call erases the first
+- Generating ALL tasks in a single Write \u2014 hits output limits, causes stalls
 </write_protocol>
 
 ### 7. DRAFT AS WORKING MEMORY (MANDATORY)
@@ -67823,8 +67993,8 @@ function createSisyphusJuniorAgentWithOverrides(override, systemDefaultModel, us
 }
 createSisyphusJuniorAgentWithOverrides.mode = MODE10;
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync64, readdirSync as readdirSync19, readFileSync as readFileSync43 } from "fs";
-import { join as join74, basename as basename7 } from "path";
+import { existsSync as existsSync65, readdirSync as readdirSync19, readFileSync as readFileSync44 } from "fs";
+import { join as join75, basename as basename7 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -67838,7 +68008,7 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync64(agentsDir)) {
+  if (!existsSync65(agentsDir)) {
     return [];
   }
   const entries = readdirSync19(agentsDir, { withFileTypes: true });
@@ -67846,10 +68016,10 @@ function loadAgentsFromDir(agentsDir, scope) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join74(agentsDir, entry.name);
+    const agentPath = join75(agentsDir, entry.name);
     const agentName = basename7(entry.name, ".md");
     try {
-      const content = readFileSync43(agentPath, "utf-8");
+      const content = readFileSync44(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -67876,7 +68046,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join74(getClaudeConfigDir(), "agents");
+  const userAgentsDir = join75(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -67885,7 +68055,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents(directory) {
-  const projectAgentsDir = join74(directory ?? process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join75(directory ?? process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -68017,9 +68187,12 @@ function buildPlanDemoteConfig(prometheusConfig, planOverride) {
 }
 
 // src/plugin-handlers/agent-config-handler.ts
-function hasConfiguredDefaultAgent(config3) {
+function getConfiguredDefaultAgent(config3) {
   const defaultAgent = config3.default_agent;
-  return typeof defaultAgent === "string" && defaultAgent.trim().length > 0;
+  if (typeof defaultAgent !== "string")
+    return;
+  const trimmedDefaultAgent = defaultAgent.trim();
+  return trimmedDefaultAgent.length > 0 ? trimmedDefaultAgent : undefined;
 }
 async function applyAgentConfig(params) {
   const migratedDisabledAgents = (params.pluginConfig.disabled_agents ?? []).map((agent) => {
@@ -68067,9 +68240,12 @@ async function applyAgentConfig(params) {
   const plannerEnabled = params.pluginConfig.sisyphus_agent?.planner_enabled ?? true;
   const replacePlan = params.pluginConfig.sisyphus_agent?.replace_plan ?? true;
   const shouldDemotePlan = plannerEnabled && replacePlan;
+  const configuredDefaultAgent = getConfiguredDefaultAgent(params.config);
   const configAgent = params.config.agent;
   if (isSisyphusEnabled && builtinAgents.sisyphus) {
-    if (!hasConfiguredDefaultAgent(params.config)) {
+    if (configuredDefaultAgent) {
+      params.config.default_agent = getAgentDisplayName(configuredDefaultAgent);
+    } else {
       params.config.default_agent = getAgentDisplayName("sisyphus");
     }
     const agentConfig = {
@@ -68138,7 +68314,7 @@ async function applyAgentConfig(params) {
 }
 // src/features/claude-code-command-loader/loader.ts
 import { promises as fs18 } from "fs";
-import { join as join75, basename as basename8 } from "path";
+import { join as join76, basename as basename8 } from "path";
 init_logger();
 async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
   try {
@@ -68169,7 +68345,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     if (entry.isDirectory()) {
       if (entry.name.startsWith("."))
         continue;
-      const subDirPath = join75(commandsDir, entry.name);
+      const subDirPath = join76(commandsDir, entry.name);
       const subPrefix = prefix ? `${prefix}:${entry.name}` : entry.name;
       const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix);
       commands2.push(...subCommands);
@@ -68177,7 +68353,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join75(commandsDir, entry.name);
+    const commandPath = join76(commandsDir, entry.name);
     const baseCommandName = basename8(entry.name, ".md");
     const commandName = prefix ? `${prefix}:${baseCommandName}` : baseCommandName;
     try {
@@ -68224,23 +68400,23 @@ function commandsToRecord(commands2) {
   return result;
 }
 async function loadUserCommands() {
-  const userCommandsDir = join75(getClaudeConfigDir(), "commands");
+  const userCommandsDir = join76(getClaudeConfigDir(), "commands");
   const commands2 = await loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands2);
 }
 async function loadProjectCommands(directory) {
-  const projectCommandsDir = join75(directory ?? process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join76(directory ?? process.cwd(), ".claude", "commands");
   const commands2 = await loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands2);
 }
 async function loadOpencodeGlobalCommands() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeCommandsDir = join75(configDir, "command");
+  const opencodeCommandsDir = join76(configDir, "command");
   const commands2 = await loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands2);
 }
 async function loadOpencodeProjectCommands(directory) {
-  const opencodeProjectDir = join75(directory ?? process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join76(directory ?? process.cwd(), ".opencode", "command");
   const commands2 = await loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands2);
 }
@@ -68299,8 +68475,8 @@ function remapCommandAgentFields(commands2) {
   }
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync65, readFileSync as readFileSync44 } from "fs";
-import { join as join76 } from "path";
+import { existsSync as existsSync66, readFileSync as readFileSync45 } from "fs";
+import { join as join77 } from "path";
 import { homedir as homedir14 } from "os";
 
 // src/features/claude-code-mcp-loader/transformer.ts
@@ -68342,14 +68518,14 @@ function getMcpConfigPaths() {
   const claudeConfigDir = getClaudeConfigDir();
   const cwd = process.cwd();
   return [
-    { path: join76(homedir14(), ".claude.json"), scope: "user" },
-    { path: join76(claudeConfigDir, ".mcp.json"), scope: "user" },
-    { path: join76(cwd, ".mcp.json"), scope: "project" },
-    { path: join76(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join77(homedir14(), ".claude.json"), scope: "user" },
+    { path: join77(claudeConfigDir, ".mcp.json"), scope: "user" },
+    { path: join77(cwd, ".mcp.json"), scope: "project" },
+    { path: join77(cwd, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync65(filePath)) {
+  if (!existsSync66(filePath)) {
     return null;
   }
   try {
@@ -68364,10 +68540,10 @@ function getSystemMcpServerNames() {
   const names = new Set;
   const paths = getMcpConfigPaths();
   for (const { path: path10 } of paths) {
-    if (!existsSync65(path10))
+    if (!existsSync66(path10))
       continue;
     try {
-      const content = readFileSync44(path10, "utf-8");
+      const content = readFileSync45(path10, "utf-8");
       const config3 = JSON.parse(content);
       if (!config3?.mcpServers)
         continue;
@@ -68545,25 +68721,25 @@ init_logger();
 
 // src/features/claude-code-plugin-loader/discovery.ts
 init_logger();
-import { existsSync as existsSync66, readFileSync as readFileSync45 } from "fs";
+import { existsSync as existsSync67, readFileSync as readFileSync46 } from "fs";
 import { homedir as homedir15 } from "os";
-import { join as join77 } from "path";
+import { join as join78 } from "path";
 function getPluginsBaseDir() {
   if (process.env.CLAUDE_PLUGINS_HOME) {
     return process.env.CLAUDE_PLUGINS_HOME;
   }
-  return join77(homedir15(), ".claude", "plugins");
+  return join78(homedir15(), ".claude", "plugins");
 }
 function getInstalledPluginsPath() {
-  return join77(getPluginsBaseDir(), "installed_plugins.json");
+  return join78(getPluginsBaseDir(), "installed_plugins.json");
 }
 function loadInstalledPlugins() {
   const dbPath = getInstalledPluginsPath();
-  if (!existsSync66(dbPath)) {
+  if (!existsSync67(dbPath)) {
     return null;
   }
   try {
-    const content = readFileSync45(dbPath, "utf-8");
+    const content = readFileSync46(dbPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log("Failed to load installed plugins database", error45);
@@ -68574,15 +68750,15 @@ function getClaudeSettingsPath() {
   if (process.env.CLAUDE_SETTINGS_PATH) {
     return process.env.CLAUDE_SETTINGS_PATH;
   }
-  return join77(homedir15(), ".claude", "settings.json");
+  return join78(homedir15(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync66(settingsPath)) {
+  if (!existsSync67(settingsPath)) {
     return null;
   }
   try {
-    const content = readFileSync45(settingsPath, "utf-8");
+    const content = readFileSync46(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log("Failed to load Claude settings", error45);
@@ -68590,12 +68766,12 @@ function loadClaudeSettings() {
   }
 }
 function loadPluginManifest(installPath) {
-  const manifestPath = join77(installPath, ".claude-plugin", "plugin.json");
-  if (!existsSync66(manifestPath)) {
+  const manifestPath = join78(installPath, ".claude-plugin", "plugin.json");
+  if (!existsSync67(manifestPath)) {
     return null;
   }
   try {
-    const content = readFileSync45(manifestPath, "utf-8");
+    const content = readFileSync46(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log(`Failed to load plugin manifest from ${manifestPath}`, error45);
@@ -68639,7 +68815,7 @@ function discoverInstalledPlugins(options) {
       continue;
     }
     const { installPath, scope, version: version2 } = installation;
-    if (!existsSync66(installPath)) {
+    if (!existsSync67(installPath)) {
       errors3.push({
         pluginKey,
         installPath,
@@ -68657,21 +68833,21 @@ function discoverInstalledPlugins(options) {
       pluginKey,
       manifest: manifest ?? undefined
     };
-    if (existsSync66(join77(installPath, "commands"))) {
-      loadedPlugin.commandsDir = join77(installPath, "commands");
+    if (existsSync67(join78(installPath, "commands"))) {
+      loadedPlugin.commandsDir = join78(installPath, "commands");
     }
-    if (existsSync66(join77(installPath, "agents"))) {
-      loadedPlugin.agentsDir = join77(installPath, "agents");
+    if (existsSync67(join78(installPath, "agents"))) {
+      loadedPlugin.agentsDir = join78(installPath, "agents");
     }
-    if (existsSync66(join77(installPath, "skills"))) {
-      loadedPlugin.skillsDir = join77(installPath, "skills");
+    if (existsSync67(join78(installPath, "skills"))) {
+      loadedPlugin.skillsDir = join78(installPath, "skills");
     }
-    const hooksPath = join77(installPath, "hooks", "hooks.json");
-    if (existsSync66(hooksPath)) {
+    const hooksPath = join78(installPath, "hooks", "hooks.json");
+    if (existsSync67(hooksPath)) {
       loadedPlugin.hooksPath = hooksPath;
     }
-    const mcpPath = join77(installPath, ".mcp.json");
-    if (existsSync66(mcpPath)) {
+    const mcpPath = join78(installPath, ".mcp.json");
+    if (existsSync67(mcpPath)) {
       loadedPlugin.mcpPath = mcpPath;
     }
     plugins.push(loadedPlugin);
@@ -68684,23 +68860,23 @@ function discoverInstalledPlugins(options) {
 }
 
 // src/features/claude-code-plugin-loader/command-loader.ts
-import { existsSync as existsSync67, readdirSync as readdirSync20, readFileSync as readFileSync46 } from "fs";
-import { basename as basename9, join as join78 } from "path";
+import { existsSync as existsSync68, readdirSync as readdirSync20, readFileSync as readFileSync47 } from "fs";
+import { basename as basename9, join as join79 } from "path";
 init_logger();
 function loadPluginCommands(plugins) {
   const commands2 = {};
   for (const plugin of plugins) {
-    if (!plugin.commandsDir || !existsSync67(plugin.commandsDir))
+    if (!plugin.commandsDir || !existsSync68(plugin.commandsDir))
       continue;
     const entries = readdirSync20(plugin.commandsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const commandPath = join78(plugin.commandsDir, entry.name);
+      const commandPath = join79(plugin.commandsDir, entry.name);
       const commandName = basename9(entry.name, ".md");
       const namespacedName = `${plugin.name}:${commandName}`;
       try {
-        const content = readFileSync46(commandPath, "utf-8");
+        const content = readFileSync47(commandPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -68731,27 +68907,27 @@ $ARGUMENTS
 }
 
 // src/features/claude-code-plugin-loader/skill-loader.ts
-import { existsSync as existsSync68, readdirSync as readdirSync21, readFileSync as readFileSync47 } from "fs";
-import { join as join79 } from "path";
+import { existsSync as existsSync69, readdirSync as readdirSync21, readFileSync as readFileSync48 } from "fs";
+import { join as join80 } from "path";
 init_logger();
 function loadPluginSkillsAsCommands(plugins) {
   const skills = {};
   for (const plugin of plugins) {
-    if (!plugin.skillsDir || !existsSync68(plugin.skillsDir))
+    if (!plugin.skillsDir || !existsSync69(plugin.skillsDir))
       continue;
     const entries = readdirSync21(plugin.skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith("."))
         continue;
-      const skillPath = join79(plugin.skillsDir, entry.name);
+      const skillPath = join80(plugin.skillsDir, entry.name);
       if (!entry.isDirectory() && !entry.isSymbolicLink())
         continue;
       const resolvedPath = resolveSymlink(skillPath);
-      const skillMdPath = join79(resolvedPath, "SKILL.md");
-      if (!existsSync68(skillMdPath))
+      const skillMdPath = join80(resolvedPath, "SKILL.md");
+      if (!existsSync69(skillMdPath))
         continue;
       try {
-        const content = readFileSync47(skillMdPath, "utf-8");
+        const content = readFileSync48(skillMdPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const skillName = data.name || entry.name;
         const namespacedName = `${plugin.name}:${skillName}`;
@@ -68786,8 +68962,8 @@ $ARGUMENTS
 }
 
 // src/features/claude-code-plugin-loader/agent-loader.ts
-import { existsSync as existsSync69, readdirSync as readdirSync22, readFileSync as readFileSync48 } from "fs";
-import { basename as basename10, join as join80 } from "path";
+import { existsSync as existsSync70, readdirSync as readdirSync22, readFileSync as readFileSync49 } from "fs";
+import { basename as basename10, join as join81 } from "path";
 init_logger();
 function parseToolsConfig2(toolsStr) {
   if (!toolsStr)
@@ -68804,17 +68980,17 @@ function parseToolsConfig2(toolsStr) {
 function loadPluginAgents(plugins) {
   const agents = {};
   for (const plugin of plugins) {
-    if (!plugin.agentsDir || !existsSync69(plugin.agentsDir))
+    if (!plugin.agentsDir || !existsSync70(plugin.agentsDir))
       continue;
     const entries = readdirSync22(plugin.agentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const agentPath = join80(plugin.agentsDir, entry.name);
+      const agentPath = join81(plugin.agentsDir, entry.name);
       const agentName = basename10(entry.name, ".md");
       const namespacedName = `${plugin.name}:${agentName}`;
       try {
-        const content = readFileSync48(agentPath, "utf-8");
+        const content = readFileSync49(agentPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const originalDescription = data.description || "";
         const formattedDescription = `(plugin: ${plugin.name}) ${originalDescription}`;
@@ -68838,7 +69014,7 @@ function loadPluginAgents(plugins) {
 }
 
 // src/features/claude-code-plugin-loader/mcp-server-loader.ts
-import { existsSync as existsSync70 } from "fs";
+import { existsSync as existsSync71 } from "fs";
 init_logger();
 
 // src/features/claude-code-plugin-loader/plugin-path-resolver.ts
@@ -68869,7 +69045,7 @@ function resolvePluginPaths(obj, pluginRoot) {
 async function loadPluginMcpServers(plugins) {
   const servers = {};
   for (const plugin of plugins) {
-    if (!plugin.mcpPath || !existsSync70(plugin.mcpPath))
+    if (!plugin.mcpPath || !existsSync71(plugin.mcpPath))
       continue;
     try {
       const content = await Bun.file(plugin.mcpPath).text();
@@ -68901,14 +69077,14 @@ async function loadPluginMcpServers(plugins) {
 
 // src/features/claude-code-plugin-loader/hook-loader.ts
 init_logger();
-import { existsSync as existsSync71, readFileSync as readFileSync49 } from "fs";
+import { existsSync as existsSync72, readFileSync as readFileSync50 } from "fs";
 function loadPluginHooksConfigs(plugins) {
   const configs = [];
   for (const plugin of plugins) {
-    if (!plugin.hooksPath || !existsSync71(plugin.hooksPath))
+    if (!plugin.hooksPath || !existsSync72(plugin.hooksPath))
       continue;
     try {
-      const content = readFileSync49(plugin.hooksPath, "utf-8");
+      const content = readFileSync50(plugin.hooksPath, "utf-8");
       let config3 = JSON.parse(content);
       config3 = resolvePluginPaths(config3, plugin.installPath);
       configs.push(config3);
@@ -69441,6 +69617,7 @@ function createChatMessageHandler2(args) {
     await hooks.keywordDetector?.["chat.message"]?.(input, output);
     await hooks.claudeCodeHooks?.["chat.message"]?.(input, output);
     await hooks.autoSlashCommand?.["chat.message"]?.(input, output);
+    await hooks.sisyphusGptHephaestusReminder?.["chat.message"]?.(input);
     if (hooks.startWork && isStartWorkHookOutput(output)) {
       await hooks.startWork["chat.message"]?.(input, output);
     }
@@ -69665,6 +69842,7 @@ function createToolExecuteAfterHandler3(args) {
     await hooks.categorySkillReminder?.["tool.execute.after"]?.(input, output);
     await hooks.interactiveBashSession?.["tool.execute.after"]?.(input, output);
     await hooks.editErrorRecovery?.["tool.execute.after"]?.(input, output);
+    await hooks.jsonErrorRecovery?.["tool.execute.after"]?.(input, output);
     await hooks.delegateTaskRetry?.["tool.execute.after"]?.(input, output);
     await hooks.atlasHook?.["tool.execute.after"]?.(input, output);
     await hooks.taskResumeInfo?.["tool.execute.after"]?.(input, output);
@@ -70050,9 +70228,11 @@ var HookNameSchema = exports_external.enum([
   "claude-code-hooks",
   "auto-slash-command",
   "edit-error-recovery",
+  "json-error-recovery",
   "delegate-task-retry",
   "prometheus-md-only",
   "sisyphus-junior-notepad",
+  "sisyphus-gpt-hephaestus-reminder",
   "start-work",
   "atlas",
   "unstable-agent-babysitter",