@sma1lboy/kobe 0.5.16 → 0.5.17

package/dist/bin/kobed.js

@@ -99,6 +99,7 @@ function serializeTask(task) {
     pinned: task.pinned ?? false,
     permissionMode: task.permissionMode,
     model: task.model,
+    modelEffort: task.modelEffort,
     vendor: task.vendor,
     createdAt: task.createdAt,
     updatedAt: task.updatedAt
@@ -552,6 +553,16 @@ var init_binary = __esm(() => {
 });
 
 // src/engine/claude-code-local/models.ts
+function opus47EffortChoices(id, label) {
+  return CLAUDE_OPUS_EFFORT_LEVELS.map((effort) => ({
+    vendor: "claude",
+    id,
+    effort,
+    level: effort,
+    label: `${label} \xB7 ${effort}`,
+    hint: effort === "max" ? "deepest reasoning" : `${effort} effort`
+  }));
+}
 function parseContextWindowSize(modelIdentifier) {
   const delimitedMatch = /(?:\(|\[)\s*(\d+(?:[,_]\d+)*(?:\.\d+)?)\s*([km])\s*(?:\)|\])/i.exec(modelIdentifier);
   if (delimitedMatch?.[1] && delimitedMatch[2]) {
@@ -581,11 +592,20 @@ function claudeContextWindowFor(modelId) {
     return LONG_CTX;
   return STD_CTX;
 }
-var CLAUDE_MODELS, LONG_CTX = 1e6, STD_CTX = 200000;
+var CLAUDE_OPUS_EFFORT_LEVELS, CLAUDE_MODELS, LONG_CTX = 1e6, STD_CTX = 200000;
 var init_models = __esm(() => {
+  CLAUDE_OPUS_EFFORT_LEVELS = [
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max"
+  ];
   CLAUDE_MODELS = [
     { vendor: "claude", id: "claude-opus-4-7[1m]", label: "Opus 4.7 1M", hint: "long context, default" },
+    ...opus47EffortChoices("claude-opus-4-7[1m]", "Opus 4.7 1M"),
     { vendor: "claude", id: "claude-opus-4-7", label: "Opus 4.7", hint: "most capable, slowest" },
+    ...opus47EffortChoices("claude-opus-4-7", "Opus 4.7"),
     { vendor: "claude", id: "claude-sonnet-4-6[1m]", label: "sonnet 4.6 (1M)", hint: "long context" },
     { vendor: "claude", id: "claude-sonnet-4-6", label: "sonnet 4.6" },
     { vendor: "claude", id: "claude-haiku-4-5-20251001", label: "haiku 4.5", hint: "fastest, cheapest" }
@@ -635,6 +655,10 @@ var init_capabilities = __esm(() => {
     vendorId: "claude",
     label: "Claude Code",
     models: CLAUDE_MODELS,
+    permissionModes: [
+      { id: "default", label: "default" },
+      { id: "plan", label: "plan mode" }
+    ],
     defaultModelId: resolveClaudeDefaultModelId,
     contextWindowFor: claudeContextWindowFor
   };
@@ -902,7 +926,12 @@ class SessionRegistry {
     }
     this.handles.set(handle.sessionId, handle);
   }
-  unregister(sessionId) {
+  unregister(sessionId, proc) {
+    if (proc) {
+      const existing = this.handles.get(sessionId);
+      if (existing && existing.proc !== proc)
+        return;
+    }
     this.handles.delete(sessionId);
   }
   get(sessionId) {
@@ -1062,6 +1091,9 @@ function buildArgs(opts) {
   if (opts.model) {
     args.push("--model", opts.model);
   }
+  if (opts.modelEffort) {
+    args.push("--effort", opts.modelEffort);
+  }
   if (opts.permissionMode) {
     args.push("--permission-mode", opts.permissionMode);
   }
@@ -1298,6 +1330,7 @@ class ClaudeCodeLocal {
       cwd: args.cwd,
       prompt: args.prompt,
       model: args.opts?.model,
+      modelEffort: args.opts?.modelEffort,
       permissionMode: cliPermissionMode,
       env: args.opts?.env,
       resumeSessionId: args.resumeSessionId
@@ -1373,7 +1406,7 @@ class ClaudeCodeLocal {
         if (session) {
           session.closed = true;
           this.notify(session);
-          this.registry.unregister(session.sessionId);
+          this.registry.unregister(session.sessionId, spawned.proc);
         }
         if (!bound) {
           rejectHandle(new Error("claude exited without emitting a session id"));
@@ -1509,10 +1542,25 @@ var init_binary2 = __esm(() => {
 function codexContextWindowFor(_modelId) {
   return DEFAULT_CTX;
 }
-var CODEX_MODELS, CODEX_FALLBACK_DEFAULT_MODEL_ID = "gpt-5.4-mini", DEFAULT_CTX = 400000;
+var CODEX_GPT55_EFFORT_LEVELS, CODEX_MODELS, CODEX_FALLBACK_DEFAULT_MODEL_ID = "gpt-5.4-mini", DEFAULT_CTX = 400000;
 var init_models2 = __esm(() => {
+  CODEX_GPT55_EFFORT_LEVELS = [
+    "none",
+    "low",
+    "medium",
+    "high",
+    "xhigh"
+  ];
   CODEX_MODELS = [
     { vendor: "codex", id: "gpt-5.5", label: "GPT-5.5", hint: "latest, ChatGPT-account compatible" },
+    ...CODEX_GPT55_EFFORT_LEVELS.map((effort) => ({
+      vendor: "codex",
+      id: "gpt-5.5",
+      effort,
+      level: effort,
+      label: `GPT-5.5 \xB7 ${effort}`,
+      hint: effort === "none" ? "no reasoning effort" : `${effort} reasoning`
+    })),
     { vendor: "codex", id: "gpt-5.4", label: "GPT-5.4", hint: "stable" },
     { vendor: "codex", id: "gpt-5.4-mini", label: "GPT-5.4 mini", hint: "fastest, always supported" }
   ];
@@ -1564,6 +1612,10 @@ var init_capabilities2 = __esm(() => {
     vendorId: "codex",
     label: "Codex",
     models: CODEX_MODELS,
+    permissionModes: [
+      { id: "default", label: "full access" },
+      { id: "plan", label: "plan mode" }
+    ],
     defaultModelId: resolveCodexDefaultModelId,
     contextWindowFor: codexContextWindowFor
   };
@@ -1608,6 +1660,36 @@ function isObject4(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 
+// src/engine/codex-local/synthetic.ts
+function isSyntheticCodexUserRow(blocks) {
+  if (blocks.length === 0)
+    return false;
+  for (const b of blocks) {
+    if (b.type !== "text")
+      return false;
+    const t = (b.text ?? "").trim();
+    if (!isEnvironmentContextEnvelope(t) && !isInstructionsEnvelope(t))
+      return false;
+  }
+  return true;
+}
+function visibleCodexUserText(content) {
+  const blocks = normalizeCodexContent(content);
+  if (isSyntheticCodexUserRow(blocks))
+    return null;
+  const text = blocks.filter((b) => b.type === "text").map((b) => b.text).join(" ").trim();
+  return text.length > 0 ? text : null;
+}
+function isEnvironmentContextEnvelope(text) {
+  return text.startsWith("<environment_context>") && text.endsWith("</environment_context>");
+}
+function isInstructionsEnvelope(text) {
+  return text.startsWith("# AGENTS.md instructions for ") && text.includes(`
+<INSTRUCTIONS>
+`) && text.endsWith("</INSTRUCTIONS>");
+}
+var init_synthetic = () => {};
+
 // src/engine/codex-local/history.ts
 import { readFile as readFile3, readdir as readdir3, unlink as unlink2 } from "fs/promises";
 import { homedir as homedir8 } from "os";
@@ -1702,7 +1784,7 @@ function parseJsonl2(raw, sessionId) {
     if (role !== "user" && role !== "assistant" && role !== "system")
       continue;
     const blocks = normalizeCodexContent(payload.content);
-    if (role === "user" && isEnvironmentContextEnvelope(blocks))
+    if (role === "user" && isSyntheticCodexUserRow(blocks))
       continue;
     const ts = typeof parsed.timestamp === "string" ? parsed.timestamp : new Date().toISOString();
     out.push({ role, blocks, timestamp: ts, sessionId });
@@ -1734,7 +1816,7 @@ function deriveCodexUsageMetrics(raw) {
       const payload = isObject5(parsed.payload) ? parsed.payload : undefined;
       if (payload?.type === "message" && payload.role === "user" && timestampMs !== null) {
         const blocks = normalizeCodexContent(payload.content);
-        if (!isEnvironmentContextEnvelope(blocks))
+        if (!isSyntheticCodexUserRow(blocks))
           lastUserTimestampMs = timestampMs;
       }
       continue;
@@ -1810,23 +1892,12 @@ function mergedDurationMs(intervals) {
 function numberOr(v, fallback) {
   return typeof v === "number" && Number.isFinite(v) ? v : fallback;
 }
-function isEnvironmentContextEnvelope(blocks) {
-  if (blocks.length === 0)
-    return false;
-  for (const b of blocks) {
-    if (b.type !== "text")
-      return false;
-    const t = (b.text ?? "").trim();
-    if (!t.startsWith("<environment_context>") || !t.endsWith("</environment_context>"))
-      return false;
-  }
-  return true;
-}
 function isObject5(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var defaultDeps5;
 var init_history2 = __esm(() => {
+  init_synthetic();
   defaultDeps5 = {
     sessionsDir() {
       return path5.join(homedir8(), ".codex", "sessions");
@@ -1881,47 +1952,46 @@ async function tryReadMeta(file) {
     return null;
   try {
     let buf = "";
-    let lineCount = 0;
     const processLine = (line) => {
-      lineCount++;
       const parsed = safeParse(line);
-      if (parsed) {
-        if (parsed.type === "session_meta") {
-          const payload = parsed.payload;
-          if (isObject6(payload)) {
-            if (typeof payload.id === "string")
-              sessionId = payload.id;
-            if (typeof payload.cwd === "string")
-              cwd = payload.cwd;
-          }
-        } else if (parsed.type === "response_item" && isObject6(parsed.payload)) {
-          const p = parsed.payload;
-          if (p.type === "message") {
-            messageCount++;
-            if (!firstUser && p.role === "user") {
-              firstUser = extractText(p.content)?.slice(0, PREVIEW_CHAR_CAP) ?? null;
-            }
+      if (!parsed)
+        return;
+      if (parsed.type === "session_meta") {
+        const payload = parsed.payload;
+        if (isObject6(payload)) {
+          if (typeof payload.id === "string")
+            sessionId = payload.id;
+          if (typeof payload.cwd === "string")
+            cwd = payload.cwd;
+        }
+        return;
+      }
+      if (parsed.type === "response_item" && isObject6(parsed.payload)) {
+        const p = parsed.payload;
+        if (p.type === "message") {
+          messageCount++;
+          if (!firstUser && p.role === "user") {
+            const text = visibleCodexUserText(p.content);
+            if (text)
+              firstUser = text.slice(0, PREVIEW_CHAR_CAP);
           }
         }
       }
-      return lineCount >= PREVIEW_HEAD_LINES;
     };
     const reader = handle.createReadStream({ encoding: "utf8" });
-    outer:
-      for await (const chunk of reader) {
-        buf += chunk;
-        let nl = buf.indexOf(`
+    for await (const chunk of reader) {
+      buf += chunk;
+      let nl = buf.indexOf(`
 `);
-        while (nl !== -1) {
-          const line = buf.slice(0, nl);
-          buf = buf.slice(nl + 1);
-          nl = buf.indexOf(`
+      while (nl !== -1) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        nl = buf.indexOf(`
 `);
-          if (processLine(line))
-            break outer;
-        }
+        processLine(line);
       }
-    if (lineCount < PREVIEW_HEAD_LINES && buf.trim())
+    }
+    if (buf.trim())
       processLine(buf);
   } finally {
     await handle.close().catch(() => {});
@@ -1947,29 +2017,13 @@ function safeParse(line) {
     return null;
   }
 }
-function extractText(content) {
-  if (typeof content === "string")
-    return content;
-  if (!Array.isArray(content))
-    return null;
-  for (const item of content) {
-    if (typeof item === "string" && item.length > 0)
-      return item;
-    if (isObject6(item)) {
-      const t = item.type;
-      if ((t === "input_text" || t === "output_text" || t === "text") && typeof item.text === "string") {
-        return item.text;
-      }
-    }
-  }
-  return null;
-}
 function isObject6(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var PREVIEW_HEAD_LINES = 40, PREVIEW_CHAR_CAP = 200;
+var PREVIEW_CHAR_CAP = 200;
 var init_sessions2 = __esm(() => {
   init_history2();
+  init_synthetic();
 });
 
 // src/engine/codex-local/spawn.ts
@@ -2001,6 +2055,9 @@ function buildArgs2(opts) {
   if (opts.model) {
     args.push("-m", opts.model);
   }
+  if (opts.modelEffort) {
+    args.push("-c", `model_reasoning_effort="${opts.modelEffort}"`);
+  }
   if (!isResume) {
     args.push("-C", opts.cwd);
     if (opts.permissionMode === "plan")
@@ -2038,8 +2095,8 @@ async function* parseStreamJson2(lines, opts = {}) {
     const type = typeof msg.type === "string" ? msg.type : undefined;
     if (!type)
       continue;
-    if (type === "thread.started") {
-      const sid = typeof msg.thread_id === "string" ? msg.thread_id : undefined;
+    if (type === "session_meta" || type === "thread.started") {
+      const sid = codexSessionId(msg);
       if (sid && !sessionIdEmitted) {
         sessionIdEmitted = true;
         opts.onSessionId?.(sid);
@@ -2125,6 +2182,15 @@ async function* readLines2(stream) {
 function isObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
+function codexSessionId(msg) {
+  if (msg.type === "session_meta") {
+    const payload = isObject7(msg.payload) ? msg.payload : undefined;
+    const id2 = payload?.id;
+    return typeof id2 === "string" && id2.length > 0 ? id2 : undefined;
+  }
+  const id = msg.thread_id;
+  return typeof id === "string" && id.length > 0 ? id : undefined;
+}
 function numberOr2(v, fallback) {
   return typeof v === "number" && Number.isFinite(v) ? v : fallback;
 }
@@ -2213,6 +2279,7 @@ class CodexLocal {
       cwd: args.cwd,
       prompt: args.prompt,
       model: args.opts?.model,
+      modelEffort: args.opts?.modelEffort,
       permissionMode: args.opts?.permissionMode,
       env: args.opts?.env,
       resumeSessionId: args.resumeSessionId
@@ -2226,9 +2293,18 @@ class CodexLocal {
     const queue = [];
     let session;
     let bound = false;
+    let stderrTail = "";
     const bind = (sessionId) => {
-      if (bound)
+      if (bound) {
+        if (session && session.sessionId !== sessionId) {
+          queue.push({
+            type: "error",
+            message: `codex resumed to a different session id (got ${sessionId}, expected ${session.sessionId})`
+          });
+          this.notify(session);
+        }
         return;
+      }
       bound = true;
       session = {
         sessionId,
@@ -2260,6 +2336,25 @@ class CodexLocal {
         throw err;
       }
     }
+    captureStderrTail(spawned.stderr, (chunk) => {
+      stderrTail = (stderrTail + chunk).slice(-STDERR_TAIL_CAP);
+    });
+    const exitInfo = {
+      code: null,
+      signal: null,
+      seen: false
+    };
+    const exitObserved = new Promise((resolve2) => {
+      spawned.proc.once("exit", (code, signal) => {
+        exitInfo.code = code;
+        exitInfo.signal = signal;
+        exitInfo.seen = true;
+        if (!bound) {
+          rejectHandle(new Error(formatExitMsg("codex exited before session id was captured", code, signal, stderrTail)));
+        }
+        resolve2();
+      });
+    });
     (async () => {
       const events = parseStreamJson2(readLines2(spawned.stdout), {
         onSessionId: (sid) => bind(sid)
@@ -2270,6 +2365,9 @@ class CodexLocal {
           queue.push(enriched);
           if (session)
             this.notify(session);
+          if ((enriched.type === "done" || enriched.type === "error") && session) {
+            this.registry.unregister(session.sessionId, spawned.proc);
+          }
         }
       } catch (err) {
         const ev = {
@@ -2280,27 +2378,32 @@ class CodexLocal {
         if (session)
           this.notify(session);
       } finally {
+        await Promise.race([exitObserved, new Promise((r) => setTimeout(r, 500))]);
         if (session) {
+          const code = exitInfo.code;
+          const lastEv = queue[queue.length - 1];
+          if (exitInfo.seen && typeof code === "number" && code !== 0 && lastEv?.type !== "error") {
+            queue.push({
+              type: "error",
+              message: formatExitMsg("codex exited", code, exitInfo.signal, stderrTail)
+            });
+          }
           session.closed = true;
           this.notify(session);
-          this.registry.unregister(session.sessionId);
-          this.running.delete(session.sessionId);
+          this.registry.unregister(session.sessionId, spawned.proc);
+          if (this.running.get(session.sessionId) === session) {
+            this.running.delete(session.sessionId);
+          }
         }
         if (!bound) {
           rejectHandle(new Error("codex exited without emitting a session id"));
         }
       }
     })();
-    drainStream2(spawned.stderr);
     spawned.proc.once("error", (err) => {
       if (!bound)
         rejectHandle(err);
     });
-    spawned.proc.once("exit", () => {
-      if (!bound) {
-        rejectHandle(new Error("codex exited before session id was captured"));
-      }
-    });
     return handlePromise;
   }
   notify(session) {
@@ -2310,22 +2413,37 @@ class CodexLocal {
       w();
   }
 }
-function drainStream2(stream) {
+function captureStderrTail(stream, onChunk) {
   const s = stream;
-  s.on("data", () => {});
+  s.on("data", (chunk) => {
+    onChunk(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+  });
   s.on("error", () => {});
 }
+function formatExitMsg(prefix, code, signal, stderrTail) {
+  const parts = [prefix];
+  if (typeof code === "number")
+    parts.push(`(code=${code}${signal ? `, signal=${signal}` : ""})`);
+  else if (signal)
+    parts.push(`(signal=${signal})`);
+  const detail = stderrTail.trim().split(/\r?\n/).filter(Boolean).slice(-3).join(" | ");
+  if (detail)
+    parts.push(`: ${detail}`);
+  return parts.join(" ").replace(/ : /, ": ");
+}
 function enrichUsageEvent2(ev, startedAtIso) {
   if (ev.type !== "usage")
     return ev;
   return { type: "usage", ...withTotalSpeedForTurn(ev, startedAtIso, new Date().toISOString()) };
 }
+var STDERR_TAIL_CAP;
 var init_codex_local = __esm(() => {
   init_binary2();
   init_capabilities2();
   init_history2();
   init_sessions2();
   init_spawn2();
+  STDERR_TAIL_CAP = 4 * 1024;
 });
 
 // src/orchestrator/bridge/server.ts
@@ -3761,7 +3879,7 @@ function allModels() {
     if (!caps)
       continue;
     for (const m of caps.models) {
-      const key = `${m.vendor}:${m.id}`;
+      const key = `${m.vendor}:${m.id}:${m.effort ?? ""}`;
       if (seen.has(key))
         continue;
       seen.add(key);
@@ -3770,15 +3888,17 @@ function allModels() {
   }
   return out;
 }
-function modelLabelFor(modelId) {
+function modelLabelFor(modelId, effort) {
   const resolved = modelId ?? defaultCapabilities.defaultModelId();
   for (const caps of Object.values(ENGINE_REGISTRY)) {
     if (!caps)
       continue;
-    const match = caps.models.find((m) => m.id === resolved);
+    const match = caps.models.find((m) => m.id === resolved && (effort === undefined || m.effort === effort));
     if (match)
       return match.label;
   }
+  if (effort)
+    return `${resolved} \xB7 ${effort}`;
   return resolved;
 }
 var ENGINE_REGISTRY, ENGINE_IDENTITIES, defaultCapabilities, defaultIdentity;
@@ -3940,6 +4060,14 @@ function nextChatTabSeq(tabs) {
       max = t.seq;
   return max + 1;
 }
+function worktreeSlug(task) {
+  if (task.kind === "main")
+    return "";
+  if (!task.worktreePath)
+    return "";
+  const match = task.worktreePath.match(/([^/\\]+)[/\\]*$/);
+  return match ? match[1] ?? "" : "";
+}
 var toTaskId = (id) => id, DEFAULT_TASK_VENDOR = "claude";
 
 // src/orchestrator/index/ulid.ts
@@ -4354,6 +4482,548 @@ var init_session_pump = __esm(() => {
   init_core();
 });
 
+// src/orchestrator/worktree/animal-names.ts
+var ANIMAL_NAMES;
+var init_animal_names = __esm(() => {
+  ANIMAL_NAMES = [
+    "aardvark",
+    "addax",
+    "adder",
+    "agouti",
+    "albatross",
+    "alpaca",
+    "anaconda",
+    "anchovy",
+    "anglerfish",
+    "anole",
+    "anteater",
+    "antelope",
+    "ape",
+    "argali",
+    "armadillo",
+    "avocet",
+    "axolotl",
+    "baboon",
+    "badger",
+    "banteng",
+    "barracuda",
+    "basilisk",
+    "bass",
+    "bat",
+    "beagle",
+    "bear",
+    "beaver",
+    "bee",
+    "beetle",
+    "beluga",
+    "betta",
+    "bison",
+    "blackbird",
+    "blenny",
+    "bluebird",
+    "bluegill",
+    "boar",
+    "bobcat",
+    "bonito",
+    "bovid",
+    "buffalo",
+    "bullfrog",
+    "bunting",
+    "bushbuck",
+    "butterfly",
+    "buzzard",
+    "caiman",
+    "camel",
+    "canary",
+    "capybara",
+    "caracal",
+    "cardinal",
+    "caribou",
+    "carp",
+    "cassowary",
+    "caterpillar",
+    "catfish",
+    "chameleon",
+    "chamois",
+    "char",
+    "cheetah",
+    "chickadee",
+    "chimp",
+    "chinchilla",
+    "chipmunk",
+    "chough",
+    "cicada",
+    "civet",
+    "clam",
+    "clownfish",
+    "cobra",
+    "cockatoo",
+    "condor",
+    "coot",
+    "copperhead",
+    "coral",
+    "cormorant",
+    "cougar",
+    "coyote",
+    "crab",
+    "crane",
+    "crawfish",
+    "crayfish",
+    "cricket",
+    "crocodile",
+    "crow",
+    "cuckoo",
+    "curlew",
+    "cuttlefish",
+    "deer",
+    "dikdik",
+    "dingo",
+    "dolphin",
+    "donkey",
+    "dormouse",
+    "dotterel",
+    "dove",
+    "dragonfly",
+    "dromedary",
+    "duck",
+    "dugong",
+    "dunlin",
+    "eagle",
+    "echidna",
+    "eel",
+    "egret",
+    "eider",
+    "eland",
+    "elephant",
+    "elk",
+    "emu",
+    "ermine",
+    "falcon",
+    "fawn",
+    "ferret",
+    "finch",
+    "firefly",
+    "flamingo",
+    "flounder",
+    "fox",
+    "frog",
+    "gadwall",
+    "gannet",
+    "gaur",
+    "gazelle",
+    "gecko",
+    "gemsbok",
+    "gerbil",
+    "gharial",
+    "gibbon",
+    "gnu",
+    "goat",
+    "goby",
+    "godwit",
+    "goldfish",
+    "goose",
+    "gopher",
+    "goral",
+    "gorilla",
+    "goshawk",
+    "grackle",
+    "grasshopper",
+    "grayling",
+    "grebe",
+    "grouse",
+    "guanaco",
+    "guillemot",
+    "guineafowl",
+    "guppy",
+    "halibut",
+    "hammerhead",
+    "hamster",
+    "hare",
+    "harrier",
+    "hartebeest",
+    "hawk",
+    "hedgehog",
+    "heron",
+    "herring",
+    "hippo",
+    "hornbill",
+    "hornet",
+    "horse",
+    "hummingbird",
+    "hyena",
+    "ibex",
+    "ibis",
+    "iguana",
+    "impala",
+    "indri",
+    "jacana",
+    "jackal",
+    "jaguar",
+    "jay",
+    "jellyfish",
+    "jerboa",
+    "junco",
+    "kakapo",
+    "kangaroo",
+    "kestrel",
+    "killdeer",
+    "kingfisher",
+    "kinglet",
+    "kite",
+    "kiwi",
+    "koala",
+    "kookaburra",
+    "krait",
+    "krill",
+    "kudu",
+    "ladybug",
+    "lamprey",
+    "langur",
+    "lapwing",
+    "lark",
+    "lemming",
+    "lemur",
+    "leopard",
+    "limpet",
+    "lion",
+    "lionfish",
+    "lizard",
+    "llama",
+    "lobster",
+    "locust",
+    "loon",
+    "lorikeet",
+    "loris",
+    "lynx",
+    "macaque",
+    "macaw",
+    "mackerel",
+    "magpie",
+    "mallard",
+    "mamba",
+    "mammoth",
+    "manatee",
+    "mandrill",
+    "manta",
+    "mantis",
+    "marlin",
+    "marmoset",
+    "marmot",
+    "marten",
+    "meerkat",
+    "merganser",
+    "mink",
+    "minnow",
+    "mole",
+    "mongoose",
+    "monitor",
+    "monkey",
+    "moose",
+    "moth",
+    "mouflon",
+    "mouse",
+    "mudpuppy",
+    "mule",
+    "muntjac",
+    "musk",
+    "muskox",
+    "muskrat",
+    "mussel",
+    "mustang",
+    "narwhal",
+    "newt",
+    "nightingale",
+    "numbat",
+    "nuthatch",
+    "nyala",
+    "ocelot",
+    "octopus",
+    "okapi",
+    "opossum",
+    "orangutan",
+    "orca",
+    "oriole",
+    "oryx",
+    "osprey",
+    "ostrich",
+    "otter",
+    "owl",
+    "oyster",
+    "oystercatcher",
+    "paca",
+    "panda",
+    "pangolin",
+    "panther",
+    "parakeet",
+    "parrot",
+    "parrotfish",
+    "partridge",
+    "peafowl",
+    "pelican",
+    "penguin",
+    "perch",
+    "petrel",
+    "pheasant",
+    "pigeon",
+    "pika",
+    "pike",
+    "pintail",
+    "pipefish",
+    "platypus",
+    "plover",
+    "pollock",
+    "pony",
+    "porcupine",
+    "porpoise",
+    "possum",
+    "ptarmigan",
+    "puffin",
+    "puma",
+    "pupfish",
+    "python",
+    "quail",
+    "quetzal",
+    "quokka",
+    "quoll",
+    "rabbit",
+    "raccoon",
+    "rail",
+    "rat",
+    "rattler",
+    "raven",
+    "ray",
+    "redpoll",
+    "reindeer",
+    "remora",
+    "rhino",
+    "roadrunner",
+    "robin",
+    "rook",
+    "sable",
+    "sailfish",
+    "salamander",
+    "salmon",
+    "sandpiper",
+    "sardine",
+    "scallop",
+    "scaup",
+    "scorpion",
+    "seahorse",
+    "seal",
+    "serval",
+    "shark",
+    "shearwater",
+    "shrew",
+    "shrike",
+    "shrimp",
+    "siskin",
+    "sitatunga",
+    "skate",
+    "skink",
+    "skua",
+    "skunk",
+    "sloth",
+    "smelt",
+    "snail",
+    "snipe",
+    "solenodon",
+    "sparrow",
+    "spider",
+    "springbok",
+    "squid",
+    "squirrel",
+    "starfish",
+    "starling",
+    "stilt",
+    "stingray",
+    "stoat",
+    "stork",
+    "sunbird",
+    "sunfish",
+    "swallow",
+    "swan",
+    "swift",
+    "swordfish",
+    "tahr",
+    "takin",
+    "tamarin",
+    "tanager",
+    "tapir",
+    "tarantula",
+    "tarpon",
+    "tarsier",
+    "teal",
+    "tenrec",
+    "terrapin",
+    "tern",
+    "tetra",
+    "thrasher",
+    "thrush",
+    "tiger",
+    "toad",
+    "tortoise",
+    "toucan",
+    "treecreeper",
+    "treefrog",
+    "trout",
+    "tuatara",
+    "tuna",
+    "turkey",
+    "turtle",
+    "urchin",
+    "urial",
+    "vicuna",
+    "viper",
+    "vole",
+    "vulture",
+    "wagtail",
+    "wallaby",
+    "walleye",
+    "walrus",
+    "warbler",
+    "warthog",
+    "waterbuck",
+    "weasel",
+    "wildebeest",
+    "wolf",
+    "wolverine",
+    "wombat",
+    "woodcock",
+    "woodpecker",
+    "wrasse",
+    "wren",
+    "yak",
+    "zebra",
+    "zebu",
+    "zorilla"
+  ];
+});
+
+// src/orchestrator/worktree/paths.ts
+import fs2 from "fs";
+import path7 from "path";
+function worktreeRootFor(repo) {
+  if (!path7.isAbsolute(repo)) {
+    throw new Error(`worktreeRootFor: repo must be an absolute path, got: ${repo}`);
+  }
+  return path7.join(repo, KOBE_WORKTREE_ROOT_SUBPATH);
+}
+function worktreePathFor(repo, slug) {
+  if (!slug || /[/\\\0]/.test(slug)) {
+    throw new Error(`worktreePathFor: invalid slug: ${JSON.stringify(slug)}`);
+  }
+  return path7.join(worktreeRootFor(repo), slug);
+}
+function listWorktreeDirNames(repo) {
+  const root = worktreeRootFor(repo);
+  try {
+    return fs2.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function isKobeManagedPath(repo, candidate) {
+  if (!path7.isAbsolute(repo) || !path7.isAbsolute(candidate))
+    return false;
+  const root = canonicalize(worktreeRootFor(repo));
+  const target = canonicalize(candidate);
+  const rel = path7.relative(root, target);
+  return rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel);
+}
+function canonicalize(p) {
+  try {
+    return fs2.realpathSync(p);
+  } catch {
+    return path7.resolve(p);
+  }
+}
+var KOBE_WORKTREE_ROOT_SUBPATH = ".claude/worktrees";
+var init_paths2 = () => {};
+
+// src/orchestrator/worktree/slug-allocator.ts
+class SlugAllocator {
+  activeSlugs;
+  random;
+  pool;
+  pendingByRepo = new Map;
+  chain = Promise.resolve();
+  constructor(activeSlugs, options = {}) {
+    this.activeSlugs = activeSlugs;
+    this.random = options.random ?? Math.random;
+    this.pool = options.pool ?? ANIMAL_NAMES;
+    if (this.pool.length === 0) {
+      throw new Error("SlugAllocator: animal pool cannot be empty");
+    }
+  }
+  async allocate(repo) {
+    const previous = this.chain;
+    let release;
+    this.chain = new Promise((resolve2) => {
+      release = resolve2;
+    });
+    await previous;
+    try {
+      return this.pickLocked(repo);
+    } finally {
+      release();
+    }
+  }
+  commit(repo, slug) {
+    this.deletePending(repo, slug);
+  }
+  cancel(repo, slug) {
+    this.deletePending(repo, slug);
+  }
+  pickLocked(repo) {
+    const occupied = this.occupiedSlugs(repo);
+    const candidates = this.pool.filter((n) => !occupied.has(n));
+    if (candidates.length > 0) {
+      const pick = candidates[Math.floor(this.random() * candidates.length)];
+      this.addPending(repo, pick);
+      return pick;
+    }
+    const base = this.pool[Math.floor(this.random() * this.pool.length)];
+    for (let v = 2;; v++) {
+      const candidate = `${base}-v${v}`;
+      if (!occupied.has(candidate)) {
+        this.addPending(repo, candidate);
+        return candidate;
+      }
+    }
+  }
+  occupiedSlugs(repo) {
+    const set = new Set(this.pendingByRepo.get(repo) ?? []);
+    for (const slug of this.activeSlugs(repo)) {
+      if (slug)
+        set.add(slug);
+    }
+    for (const dir of listWorktreeDirNames(repo)) {
+      set.add(dir);
+    }
+    return set;
+  }
+  addPending(repo, slug) {
+    let pending = this.pendingByRepo.get(repo);
+    if (!pending) {
+      pending = new Set;
+      this.pendingByRepo.set(repo, pending);
+    }
+    pending.add(slug);
+  }
+  deletePending(repo, slug) {
+    const pending = this.pendingByRepo.get(repo);
+    if (!pending)
+      return;
+    pending.delete(slug);
+    if (pending.size === 0)
+      this.pendingByRepo.delete(repo);
+  }
+}
+var init_slug_allocator = __esm(() => {
+  init_animal_names();
+  init_paths2();
+});
+
 // src/orchestrator/core.ts
 var exports_core = {};
 __export(exports_core, {
@@ -4416,6 +5086,8 @@ class Orchestrator {
   requestIdCounter = 0;
   sessionPump;
   pendingWorktreeOpts = new Map;
+  slugAllocator;
+  ensureWorktreeLatches = new Map;
   tasksAcc;
   setTasks;
   unsubscribeStore;
@@ -4445,6 +5117,7 @@ class Orchestrator {
     this.store = deps.store;
     this.worktrees = deps.worktrees;
     this.metadataSuggester = deps.metadataSuggester ?? new MetadataSuggester;
+    this.slugAllocator = new SlugAllocator((repo) => this.store.list().filter((t) => t.repo === repo && !t.archived).map((t) => worktreeSlug(t)).filter((s) => s.length > 0));
     const [tasks, setTasks] = createSignal(this.store.list());
     this.tasksAcc = tasks;
     this.setTasks = (next) => setTasks(() => next);
@@ -4475,6 +5148,9 @@ class Orchestrator {
   modelForTab(task, tab, engine) {
     return tab.model ?? task.model ?? engine.capabilities.defaultModelId();
   }
+  modelEffortForTab(task, tab) {
+    return tab.modelEffort ?? task.modelEffort;
+  }
   engineForTab(task, tab) {
     return this.engineForVendor(this.vendorForTab(task, tab));
   }
@@ -4639,26 +5315,49 @@ class Orchestrator {
   async ensureWorktree(task) {
     if (task.worktreePath)
       return task;
+    const inflight = this.ensureWorktreeLatches.get(task.id);
+    if (inflight) {
+      await inflight;
+      return this.requireTask(task.id);
+    }
+    const latch = this.doEnsureWorktree(task);
+    this.ensureWorktreeLatches.set(task.id, latch);
+    try {
+      return await latch;
+    } finally {
+      this.ensureWorktreeLatches.delete(task.id);
+    }
+  }
+  async doEnsureWorktree(task) {
     const opts = this.pendingWorktreeOpts.get(task.id);
     const branch = opts?.branch ?? `kobe/tmp-${task.id.slice(-8).toLowerCase()}`;
     const baseRef = opts?.baseRef;
+    const slug = await this.slugAllocator.allocate(task.repo);
     let info;
     try {
       info = await this.worktrees.createForTask({
         repo: task.repo,
-        taskId: task.id,
+        slug,
         branch,
         baseRef
       });
     } catch (err) {
+      this.slugAllocator.cancel(task.repo, slug);
       const message = err instanceof Error ? err.message : String(err);
       throw new Error(summarizeWorktreeError(message, task.repo, baseRef ?? null), { cause: err });
     }
-    this.pendingWorktreeOpts.delete(task.id);
-    return await this.store.update(task.id, {
-      branch: info.branch,
-      worktreePath: info.path
-    });
+    try {
+      this.pendingWorktreeOpts.delete(task.id);
+      const updated = await this.store.update(task.id, {
+        branch: info.branch,
+        worktreePath: info.path
+      });
+      this.slugAllocator.commit(task.repo, slug);
+      return updated;
+    } catch (err) {
+      this.slugAllocator.cancel(task.repo, slug);
+      throw err;
+    }
   }
   async maybeRenameTempBranch(taskId, tabId, prompt) {
     if (!prompt || prompt.trim().length === 0)
@@ -4756,13 +5455,15 @@ class Orchestrator {
     }
     const engine = targetTab.sessionId ? await this.engineForTabRun(task, targetTab) : this.engineForTab(task, targetTab);
     const modelToUse = this.modelForTab(task, targetTab, engine);
+    const modelEffortToUse = this.modelEffortForTab(task, targetTab);
     let handle;
     if (targetTab.sessionId) {
       handle = await engine.resume(targetTab.sessionId, promptToSend, {
         cwd: task.worktreePath,
         env: { KOBE_RESUME_CWD: task.worktreePath },
         permissionMode: task.permissionMode,
-        model: modelToUse
+        model: modelToUse,
+        modelEffort: modelEffortToUse
       });
     } else {
       let releaseLatch = () => {};
@@ -4773,7 +5474,8 @@ class Orchestrator {
       try {
         handle = await engine.spawn(task.worktreePath, promptToSend, {
           permissionMode: task.permissionMode,
-          model: modelToUse
+          model: modelToUse,
+          modelEffort: modelEffortToUse
         });
         await this.updateTab(task.id, targetTab.id, { sessionId: handle.sessionId });
         if (task.title === PLACEHOLDER_TASK_TITLE && prompt && prompt.trim().length > 0) {
@@ -4888,13 +5590,13 @@ class Orchestrator {
       return;
     await this.store.update(task.id, { permissionMode: mode });
   }
-  async setModel(id, model, tabId) {
+  async setModel(id, model, tabId, modelEffort) {
     const task = this.requireTask(id);
     const tab = this.resolveTab(task, tabId);
     const vendor = model ? capabilitiesForModelId(model).vendorId : this.vendorForTab(task, tab);
-    if (tab.model === model && this.vendorForTab(task, tab) === vendor)
+    if (tab.model === model && tab.modelEffort === modelEffort && this.vendorForTab(task, tab) === vendor)
       return;
-    await this.updateTab(task.id, tab.id, { model, vendor });
+    await this.updateTab(task.id, tab.id, { model, modelEffort, vendor });
   }
   async setTitle(id, title) {
     const task = this.requireTask(id);
@@ -5268,6 +5970,7 @@ var init_core = __esm(() => {
   init_metadata_suggester();
   init_pr();
   init_session_pump();
+  init_slug_allocator();
   IllegalTransitionError = class IllegalTransitionError extends Error {
     from;
     to;
@@ -5420,6 +6123,7 @@ class TaskIndexStore {
           seq: 1,
           createdAt: now,
           ...rest.model ? { model: rest.model } : {},
+          ...rest.modelEffort ? { modelEffort: rest.modelEffort } : {},
           vendor: rest.vendor ?? DEFAULT_TASK_VENDOR
         }
       ];
@@ -5587,6 +6291,7 @@ function coerceTask(value) {
         createdAt: tt.createdAt,
         ...typeof tt.title === "string" ? { title: tt.title } : {},
         ...typeof tt.model === "string" ? { model: tt.model } : {},
+        ...isModelEffortLevel(tt.modelEffort) ? { modelEffort: tt.modelEffort } : {},
         ...isVendorId(tt.vendor) ? { vendor: tt.vendor } : {}
       };
       tabs.push(tab);
@@ -5620,6 +6325,7 @@ function coerceTask(value) {
     kind: v.kind === "main" ? "main" : "task",
     permissionMode: isPermissionMode(v.permissionMode) ? v.permissionMode : undefined,
     model: typeof v.model === "string" ? v.model : undefined,
+    modelEffort: isModelEffortLevel(v.modelEffort) ? v.modelEffort : undefined,
     vendor: resolveTaskVendor(v.vendor, typeof v.model === "string" ? v.model : undefined),
     createdAt: v.createdAt,
     updatedAt: v.updatedAt
@@ -5628,6 +6334,9 @@ function coerceTask(value) {
 function isPermissionMode(v) {
   return v === "default" || v === "plan";
 }
+function isModelEffortLevel(v) {
+  return v === "none" || v === "minimal" || v === "low" || v === "medium" || v === "high" || v === "xhigh" || v === "max";
+}
 function isVendorId(v) {
   return typeof v === "string" && v in ENGINE_REGISTRY;
 }
@@ -5690,39 +6399,6 @@ var init_git = __esm(() => {
   };
 });
 
-// src/orchestrator/worktree/paths.ts
-import fs2 from "fs";
-import path7 from "path";
-function worktreeRootFor(repo) {
-  if (!path7.isAbsolute(repo)) {
-    throw new Error(`worktreeRootFor: repo must be an absolute path, got: ${repo}`);
-  }
-  return path7.join(repo, KOBE_WORKTREE_ROOT_SUBPATH);
-}
-function worktreePathFor(repo, taskId) {
-  if (!taskId || /[/\\\0]/.test(taskId)) {
-    throw new Error(`worktreePathFor: invalid taskId: ${JSON.stringify(taskId)}`);
-  }
-  return path7.join(worktreeRootFor(repo), taskId);
-}
-function isKobeManagedPath(repo, candidate) {
-  if (!path7.isAbsolute(repo) || !path7.isAbsolute(candidate))
-    return false;
-  const root = canonicalize(worktreeRootFor(repo));
-  const target = canonicalize(candidate);
-  const rel = path7.relative(root, target);
-  return rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel);
-}
-function canonicalize(p) {
-  try {
-    return fs2.realpathSync(p);
-  } catch {
-    return path7.resolve(p);
-  }
-}
-var KOBE_WORKTREE_ROOT_SUBPATH = ".claude/worktrees";
-var init_paths2 = () => {};
-
 // src/orchestrator/worktree/manager.ts
 import fs3 from "fs";
 import path8 from "path";
@@ -5757,7 +6433,7 @@ class GitWorktreeManager {
     return info;
   }
   async createForTask(args) {
-    const target = worktreePathFor(args.repo, args.taskId);
+    const target = worktreePathFor(args.repo, args.slug);
     return this.create(args.repo, args.branch, target, args.baseRef);
   }
   async remove(worktreePath, opts) {
@@ -6463,7 +7139,11 @@ async function startDaemonServer(orch, options = {}) {
       }
       case "task.model": {
         const taskId = requireString2(payload, "taskId");
-        await orch.setModel(taskId, optionalString2(payload, "model"), optionalString2(payload, "tabId"));
+        const modelEffort = optionalString2(payload, "modelEffort");
+        if (modelEffort !== undefined && modelEffort !== "none" && modelEffort !== "minimal" && modelEffort !== "low" && modelEffort !== "medium" && modelEffort !== "high" && modelEffort !== "xhigh" && modelEffort !== "max") {
+          throw new Error("modelEffort must be a supported effort level");
+        }
+        await orch.setModel(taskId, optionalString2(payload, "model"), optionalString2(payload, "tabId"), modelEffort);
         broadcastTaskUpdated(orch, clients, taskId);
         return {};
       }