@hung319/opencode-hive 1.3.1 → 1.3.4

package/dist/index.js

@@ -13,8 +13,223 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/utils/context-compression.ts
+var exports_context_compression = {};
+__export(exports_context_compression, {
+  needsCompression: () => needsCompression,
+  getContextUsage: () => getContextUsage,
+  estimateTokens: () => estimateTokens,
+  createCompactionHook: () => createCompactionHook,
+  compressContext: () => compressContext,
+  buildCompressionHint: () => buildCompressionHint
+});
+function estimateTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    if (typeof msg.content === "string") {
+      total += msg.content.length / 4;
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (typeof part === "string") {
+          total += part.length / 4;
+        } else if (part && typeof part === "object") {
+          const p = part;
+          if (p.type === "text") {
+            total += (p.text?.length ?? 0) / 4;
+          } else if (p.type === "tool_result") {
+            total += (p.content?.length ?? 0) / 6;
+          }
+        }
+      }
+    }
+  }
+  return Math.ceil(total);
+}
+function getContextUsage(messages, contextLimit) {
+  const tokens = estimateTokens(messages);
+  return tokens / contextLimit;
+}
+function needsCompression(messages, contextLimit, config2 = DEFAULT_CONFIG) {
+  if (!config2.enabled)
+    return false;
+  return getContextUsage(messages, contextLimit) >= config2.threshold;
+}
+function deduplicateToolCalls(messages) {
+  const seen = new Map;
+  const result = [];
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== "assistant" || !msg.tool_calls?.length) {
+      result.unshift(msg);
+      continue;
+    }
+    for (const toolCall of msg.tool_calls) {
+      const key = `${toolCall.name}:${JSON.stringify(toolCall.arguments || {}).slice(0, 100)}`;
+      if (!seen.has(key)) {
+        seen.set(key, i);
+      }
+    }
+  }
+  const keptIndices = new Set(seen.values());
+  return messages.filter((_, idx) => keptIndices.has(idx));
+}
+function removeSupersededWrites(messages) {
+  const latestWrite = new Map;
+  const result = [];
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== "assistant" || !msg.tool_calls?.length)
+      continue;
+    for (const toolCall of msg.tool_calls) {
+      if (toolCall.name === "filesystem_write_file" || toolCall.name === "write") {
+        const args2 = toolCall.arguments;
+        if (args2?.path) {
+          latestWrite.set(args2.path, i);
+        }
+      }
+    }
+  }
+  for (let i = 0;i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== "assistant" || !msg.tool_calls?.length) {
+      result.push(msg);
+      continue;
+    }
+    const filteredCalls = msg.tool_calls.filter((tc) => {
+      if (tc.name === "filesystem_write_file" || tc.name === "write") {
+        const args2 = tc.arguments;
+        if (args2?.path) {
+          return latestWrite.get(args2.path) === i;
+        }
+      }
+      return true;
+    });
+    if (filteredCalls.length > 0) {
+      result.push({ ...msg, tool_calls: filteredCalls });
+    }
+  }
+  return result;
+}
+function purgeErrors(messages) {
+  return messages.filter((msg) => {
+    if (msg.role !== "tool")
+      return true;
+    const content = typeof msg.content === "string" ? msg.content : "";
+    if (content.includes("Error:") || content.includes("error:") || content.includes("Failed:") || content.includes("failed:")) {
+      return false;
+    }
+    if (!content.trim() || content === "undefined" || content === "null") {
+      return false;
+    }
+    return true;
+  });
+}
+function truncateLongOutputs(messages, maxLength = 2000) {
+  return messages.map((msg) => {
+    if (msg.role !== "tool")
+      return msg;
+    const content = typeof msg.content === "string" ? msg.content : "";
+    if (content.length > maxLength) {
+      const kept = content.slice(0, maxLength / 2) + `
+
+[... ` + (content.length - maxLength) + ` bytes truncated ...]
+
+` + content.slice(-maxLength / 2);
+      return { ...msg, content: kept };
+    }
+    return msg;
+  });
+}
+function trimOldToolCalls(messages, maxToolCalls) {
+  let toolCallCount = 0;
+  return messages.filter((msg) => {
+    if (msg.role !== "assistant" || !msg.tool_calls?.length) {
+      return true;
+    }
+    const msgToolCount = msg.tool_calls.length;
+    if (toolCallCount + msgToolCount <= maxToolCalls) {
+      toolCallCount += msgToolCount;
+      return true;
+    }
+    const remaining = maxToolCalls - toolCallCount;
+    if (remaining > 0) {
+      toolCallCount = maxToolCalls;
+      return {
+        ...msg,
+        tool_calls: msg.tool_calls.slice(-remaining)
+      };
+    }
+    return false;
+  });
+}
+function compressContext(messages, config2 = DEFAULT_CONFIG, contextLimit = 200000) {
+  const cfg = { ...DEFAULT_CONFIG, ...config2 };
+  const startTokens = estimateTokens(messages);
+  let compressed = [...messages];
+  compressed = purgeErrors(compressed);
+  compressed = deduplicateToolCalls(compressed);
+  compressed = removeSupersededWrites(compressed);
+  compressed = truncateLongOutputs(compressed, 3000);
+  compressed = trimOldToolCalls(compressed, cfg.maxToolCalls);
+  const endTokens = estimateTokens(compressed);
+  return {
+    compressed,
+    stats: {
+      originalTokens: startTokens,
+      compressedTokens: endTokens,
+      reductionRatio: startTokens > 0 ? (startTokens - endTokens) / startTokens : 0,
+      originalMessages: messages.length,
+      compressedMessages: compressed.length
+    }
+  };
+}
+function buildCompressionHint() {
+  return `
+## Context Compression Active
+
+The conversation has been compressed to fit within the context window.
+- Previous tool calls may have been deduplicated or truncated
+- Only the most recent and relevant information is retained
+- Focus on continuing from the current state rather than redoing completed work
+
+If you need context from earlier in the conversation, you can:
+- Ask the user to provide relevant context
+- Use hive_context_write to check for saved context
+- Use hive_plan_read to review the current plan
+`;
+}
+function createCompactionHook(config2 = DEFAULT_CONFIG) {
+  const cfg = { ...DEFAULT_CONFIG, ...config2 };
+  return function compactionHook(input, output) {
+    const messages = input.messages || [];
+    const contextLimit = input.contextLimit || 200000;
+    if (!needsCompression(messages, contextLimit, cfg)) {
+      return;
+    }
+    const { compressed, stats } = compressContext(messages, cfg, contextLimit);
+    output.context.push(buildCompressionHint());
+    console.log(`[hive:compaction] Compressed context: ${stats.originalTokens} → ${stats.compressedTokens} tokens (${Math.round(stats.reductionRatio * 100)}% reduction)`);
+  };
+}
+var DEFAULT_CONFIG;
+var init_context_compression = __esm(() => {
+  DEFAULT_CONFIG = {
+    threshold: 0.5,
+    enabled: true,
+    protectedTools: [
+      "hive_feature_create",
+      "hive_plan_write",
+      "hive_worktree_commit",
+      "hive_merge"
+    ],
+    protectUserMessages: true,
+    maxToolCalls: 50
+  };
+});
+
 // src/index.ts
 import * as path8 from "path";
 import * as os from "os";
@@ -1150,8 +1365,8 @@ function getLengthableOrigin(input) {
     return "string";
   return "unknown";
 }
-function issue(...args) {
-  const [iss, input, inst] = args;
+function issue(...args2) {
+  const [iss, input, inst] = args2;
   if (typeof iss === "string") {
     return {
       message: iss,
@@ -1538,20 +1753,20 @@ var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
 var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
 var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
-function timeSource(args) {
+function timeSource(args2) {
   const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
-  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+  const regex = typeof args2.precision === "number" ? args2.precision === -1 ? `${hhmm}` : args2.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args2.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
   return regex;
 }
-function time(args) {
-  return new RegExp(`^${timeSource(args)}$`);
+function time(args2) {
+  return new RegExp(`^${timeSource(args2)}$`);
 }
-function datetime(args) {
-  const time2 = timeSource({ precision: args.precision });
+function datetime(args2) {
+  const time2 = timeSource({ precision: args2.precision });
   const opts = ["Z"];
-  if (args.local)
+  if (args2.local)
     opts.push("");
-  if (args.offset)
+  if (args2.offset)
     opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
   const timeRegex = `${time2}(?:${opts.join("|")})`;
   return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
@@ -2134,11 +2349,11 @@ var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (ins
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/core/doc.js
 class Doc {
-  constructor(args = []) {
+  constructor(args2 = []) {
     this.content = [];
     this.indent = 0;
     if (this)
-      this.args = args;
+      this.args = args2;
   }
   indented(fn) {
     this.indent += 1;
@@ -2162,10 +2377,10 @@ class Doc {
   }
   compile() {
     const F = Function;
-    const args = this?.args;
+    const args2 = this?.args;
     const content = this?.content ?? [``];
     const lines = [...content.map((x) => `  ${x}`)];
-    return new F(...args, lines.join(`
+    return new F(...args2, lines.join(`
 `));
   }
 }
@@ -2948,24 +3163,24 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     }
     doc.write(`const newResult = {};`);
     for (const key of normalized.keys) {
-      const id = ids[key];
+      const id2 = ids[key];
       const k = esc(key);
-      doc.write(`const ${id} = ${parseStr(key)};`);
+      doc.write(`const ${id2} = ${parseStr(key)};`);
       doc.write(`
-        if (${id}.issues.length) {
-          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+        if (${id2}.issues.length) {
+          payload.issues = payload.issues.concat(${id2}.issues.map(iss => ({
             ...iss,
             path: iss.path ? [${k}, ...iss.path] : [${k}]
           })));
         }
         
         
-        if (${id}.value === undefined) {
+        if (${id2}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
           }
         } else {
-          newResult[${k}] = ${id}.value;
+          newResult[${k}] = ${id2}.value;
         }
         
       `);
@@ -3883,8 +4098,8 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
     if (typeof func !== "function") {
       throw new Error("implement() must be called with a function");
     }
-    return function(...args) {
-      const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
+    return function(...args2) {
+      const parsedArgs = inst._def.input ? parse(inst._def.input, args2) : args2;
       const result = Reflect.apply(func, this, parsedArgs);
       if (inst._def.output) {
         return parse(inst._def.output, result);
@@ -3896,8 +4111,8 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
     if (typeof func !== "function") {
       throw new Error("implementAsync() must be called with a function");
     }
-    return async function(...args) {
-      const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args;
+    return async function(...args2) {
+      const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args2) : args2;
       const result = await Reflect.apply(func, this, parsedArgs);
       if (inst._def.output) {
         return await parseAsync(inst._def.output, result);
@@ -3923,22 +4138,22 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
     }
     return payload;
   };
-  inst.input = (...args) => {
+  inst.input = (...args2) => {
     const F = inst.constructor;
-    if (Array.isArray(args[0])) {
+    if (Array.isArray(args2[0])) {
       return new F({
         type: "function",
         input: new $ZodTuple({
           type: "tuple",
-          items: args[0],
-          rest: args[1]
+          items: args2[0],
+          rest: args2[1]
         }),
         output: inst._def.output
       });
     }
     return new F({
       type: "function",
-      input: args[0],
+      input: args2[0],
       output: inst._def.output
     });
   };
@@ -10945,13 +11160,13 @@ class JSONSchemaGenerator {
       const defsSegment = this.target === "draft-2020-12" ? "$defs" : "definitions";
       if (params.external) {
         const externalId = params.external.registry.get(entry[0])?.id;
-        const uriGenerator = params.external.uri ?? ((id2) => id2);
+        const uriGenerator = params.external.uri ?? ((id3) => id3);
         if (externalId) {
           return { ref: uriGenerator(externalId) };
         }
-        const id = entry[1].defId ?? entry[1].schema.id ?? `schema${this.counter++}`;
-        entry[1].defId = id;
-        return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
+        const id2 = entry[1].defId ?? entry[1].schema.id ?? `schema${this.counter++}`;
+        entry[1].defId = id2;
+        return { defId: id2, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id2}` };
       }
       if (entry[1] === root) {
         return { ref: "#" };
@@ -10997,8 +11212,8 @@ class JSONSchemaGenerator {
           continue;
         }
       }
-      const id = this.metadataRegistry.get(entry[0])?.id;
-      if (id) {
+      const id2 = this.metadataRegistry.get(entry[0])?.id;
+      if (id2) {
         extractToDef(entry);
         continue;
       }
@@ -11054,10 +11269,10 @@ class JSONSchemaGenerator {
       console.warn(`Invalid target: ${this.target}`);
     }
     if (params.external?.uri) {
-      const id = params.external.registry.get(schema)?.id;
-      if (!id)
+      const id2 = params.external.registry.get(schema)?.id;
+      if (!id2)
         throw new Error("Schema is missing an `id` property");
-      result.$id = params.external.uri(id);
+      result.$id = params.external.uri(id2);
     }
     Object.assign(result, root.def);
     const defs = params.external?.defs ?? {};
@@ -11369,12 +11584,12 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
     },
     configurable: true
   });
-  inst.meta = (...args) => {
-    if (args.length === 0) {
+  inst.meta = (...args2) => {
+    if (args2.length === 0) {
       return globalRegistry.get(inst);
     }
     const cl = inst.clone();
-    globalRegistry.add(cl, args[0]);
+    globalRegistry.add(cl, args2[0]);
     return cl;
   };
   inst.isOptional = () => inst.safeParse(undefined).success;
@@ -11388,18 +11603,18 @@ var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
   inst.format = bag.format ?? null;
   inst.minLength = bag.minimum ?? null;
   inst.maxLength = bag.maximum ?? null;
-  inst.regex = (...args) => inst.check(_regex(...args));
-  inst.includes = (...args) => inst.check(_includes(...args));
-  inst.startsWith = (...args) => inst.check(_startsWith(...args));
-  inst.endsWith = (...args) => inst.check(_endsWith(...args));
-  inst.min = (...args) => inst.check(_minLength(...args));
-  inst.max = (...args) => inst.check(_maxLength(...args));
-  inst.length = (...args) => inst.check(_length(...args));
-  inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
+  inst.regex = (...args2) => inst.check(_regex(...args2));
+  inst.includes = (...args2) => inst.check(_includes(...args2));
+  inst.startsWith = (...args2) => inst.check(_startsWith(...args2));
+  inst.endsWith = (...args2) => inst.check(_endsWith(...args2));
+  inst.min = (...args2) => inst.check(_minLength(...args2));
+  inst.max = (...args2) => inst.check(_maxLength(...args2));
+  inst.length = (...args2) => inst.check(_length(...args2));
+  inst.nonempty = (...args2) => inst.check(_minLength(1, ...args2));
   inst.lowercase = (params) => inst.check(_lowercase(params));
   inst.uppercase = (params) => inst.check(_uppercase(params));
   inst.trim = () => inst.check(_trim());
-  inst.normalize = (...args) => inst.check(_normalize(...args));
+  inst.normalize = (...args2) => inst.check(_normalize(...args2));
   inst.toLowerCase = () => inst.check(_toLowerCase());
   inst.toUpperCase = () => inst.check(_toUpperCase());
 });
@@ -11796,8 +12011,8 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   inst.merge = (other) => exports_util.merge(inst, other);
   inst.pick = (mask) => exports_util.pick(inst, mask);
   inst.omit = (mask) => exports_util.omit(inst, mask);
-  inst.partial = (...args) => exports_util.partial(ZodOptional, inst, args[0]);
-  inst.required = (...args) => exports_util.required(ZodNonOptional, inst, args[0]);
+  inst.partial = (...args2) => exports_util.partial(ZodOptional, inst, args2[0]);
+  inst.required = (...args2) => exports_util.required(ZodNonOptional, inst, args2[0]);
 });
 function object(shape, params) {
   const def = {
@@ -11927,10 +12142,10 @@ function map(keyType, valueType, params) {
 var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
   $ZodSet.init(inst, def);
   ZodType.init(inst, def);
-  inst.min = (...args) => inst.check(_minSize(...args));
+  inst.min = (...args2) => inst.check(_minSize(...args2));
   inst.nonempty = (params) => inst.check(_minSize(1, params));
-  inst.max = (...args) => inst.check(_maxSize(...args));
-  inst.size = (...args) => inst.check(_size(...args));
+  inst.max = (...args2) => inst.check(_maxSize(...args2));
+  inst.size = (...args2) => inst.check(_size(...args2));
 });
 function set(valueType, params) {
   return new ZodSet({
@@ -12269,11 +12484,11 @@ function _instanceof(cls, params = {
   inst._zod.bag.Class = cls;
   return inst;
 }
-var stringbool = (...args) => _stringbool({
+var stringbool = (...args2) => _stringbool({
   Codec: ZodCodec,
   Boolean: ZodBoolean,
   String: ZodString
-}, ...args);
+}, ...args2);
 function json(params) {
   const jsonSchema = lazy(() => {
     return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
@@ -12340,7 +12555,7 @@ function tool(input) {
 }
 tool.schema = exports_external;
 // src/skills/registry.generated.ts
-var BUILTIN_SKILL_NAMES = ["agents-md-mastery", "brainstorming", "code-reviewer", "dispatching-parallel-agents", "docker-mastery", "executing-plans", "parallel-exploration", "systematic-debugging", "test-driven-development", "verification-before-completion", "writing-plans"];
+var BUILTIN_SKILL_NAMES = ["agents-md-mastery", "ask-questions-if-underspecified", "brainstorming", "code-reviewer", "dispatching-parallel-agents", "docker-mastery", "executing-plans", "parallel-exploration", "systematic-debugging", "test-driven-development", "verification-before-completion", "writing-plans"];
 var BUILTIN_SKILLS = [
   {
     name: "agents-md-mastery",
@@ -12592,6 +12807,58 @@ AGENTS.md is **behavioral memory**, not documentation:
 - Test: Would agent make a mistake without this entry?
 
 **Quality > quantity. Every line counts.**`
+  },
+  {
+    name: "ask-questions-if-underspecified",
+    description: "Clarify requirements before implementing. Use when serious doubts arise.",
+    template: `# Ask Questions If Underspecified
+
+## Goal
+
+Ask the minimum set of clarifying questions needed to avoid wrong work; do not start implementing until the must-have questions are answered (or the user explicitly approves proceeding with stated assumptions).
+
+## Workflow
+
+### 1) Decide whether the request is underspecified
+
+Treat a request as underspecified if after exploring how to perform the work, some or all of the following are not clear:
+- Define the objective (what should change vs stay the same)
+- Define "done" (acceptance criteria, examples, edge cases)
+- Define scope (which files/components/users are in/out)
+- Define constraints (compatibility, performance, style, deps, time)
+- Identify environment (language/runtime versions, OS, build/test runner)
+- Clarify safety/reversibility (data migration, rollout/rollback, risk)
+
+If multiple plausible interpretations exist, assume it is underspecified.
+
+### 2) Ask must-have questions first (keep it small)
+
+Ask 1-5 questions in the first pass. Prefer questions that eliminate whole branches of work.
+
+Use the \`question\` tool to present structured choices:
+- Offer multiple-choice options with clear labels
+- Mark recommended defaults with "(Recommended)" in the label
+- Use \`multiple: true\` when the user can select several options
+- The user can always select "Other" for custom input
+
+### 3) Pause before acting
+
+Until must-have answers arrive:
+- Do not run commands, edit files, or produce a detailed plan that depends on unknowns
+- Do perform a clearly labeled, low-risk discovery step only if it does not commit you to a direction (e.g., inspect repo structure, read relevant config files)
+
+If the user explicitly asks you to proceed without answers:
+- State your assumptions as a short numbered list
+- Ask for confirmation; proceed only after they confirm or correct them
+
+### 4) Confirm interpretation, then proceed
+
+Once you have answers, restate the requirements in 1-3 sentences (including key constraints and what success looks like), then start work.
+
+## Anti-patterns
+
+- Don't ask questions you can answer with a quick, low-risk discovery read (e.g., configs, existing patterns, docs).
+- Don't ask open-ended questions if a tight multiple-choice or yes/no would eliminate ambiguity faster.`
   },
   {
     name: "brainstorming",
@@ -14804,8 +15071,527 @@ async function loadFileSkill(skillId, projectRoot, homeDir) {
   };
 }
 
+// src/tools/gitingest.ts
+async function fetchGitingest(args2) {
+  const response = await fetch("https://gitingest.com/api/ingest", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      input_text: args2.url,
+      max_file_size: args2.maxFileSize ?? 50000,
+      pattern: args2.pattern ?? "",
+      pattern_type: args2.patternType ?? "exclude"
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`gitingest API error: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return `${data.summary}
+
+${data.tree}
+
+${data.content}`;
+}
+var gitingestTool = tool({
+  description: "Fetch a GitHub repository's full content via gitingest.com. Returns summary, directory tree, and file contents optimized for LLM analysis. Use when you need to understand an external repository's structure or code.",
+  args: {
+    url: tool.schema.string().describe("GitHub repository URL (e.g., https://github.com/owner/repo)"),
+    maxFileSize: tool.schema.number().optional().describe("Maximum file size in bytes to include (default: 50000)"),
+    pattern: tool.schema.string().optional().describe("Glob pattern to filter files (e.g., '*.py' or 'src/*')"),
+    patternType: tool.schema.enum(["include", "exclude"]).optional().describe("Whether pattern includes or excludes matching files (default: exclude)")
+  },
+  async execute(args2, _context) {
+    return fetchGitingest(args2);
+  }
+});
+
+// src/tools/look-at.ts
+import { readFileSync, statSync } from "node:fs";
+import { basename, extname } from "node:path";
+var BYTES_PER_KB = 1024;
+var LARGE_FILE_THRESHOLD_KB = 100;
+var LARGE_FILE_THRESHOLD = LARGE_FILE_THRESHOLD_KB * BYTES_PER_KB;
+var MAX_LINES_WITHOUT_EXTRACT = 200;
+var MAX_SIGNATURE_LENGTH = 80;
+var MAX_JSON_KEYS_SHOWN = 50;
+var MAX_PREVIEW_LINES = 10;
+var TAIL_PREVIEW_LINES = -5;
+var STRUCTURE_HEADING = `## Structure
+`;
+var EXTRACTABLE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".md",
+  ".json",
+  ".yaml",
+  ".yml"
+];
+function extractStructure(content, ext) {
+  const lines = content.split(`
+`);
+  switch (ext) {
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx":
+      return extractTypeScriptStructure(lines);
+    case ".py":
+      return extractPythonStructure(lines);
+    case ".go":
+      return extractGoStructure(lines);
+    case ".md":
+      return extractMarkdownStructure(lines);
+    case ".json":
+      return extractJsonStructure(content);
+    case ".yaml":
+    case ".yml":
+      return extractYamlStructure(lines);
+    default:
+      return extractGenericStructure(lines);
+  }
+}
+function extractTypeScriptStructure(lines) {
+  const output = [STRUCTURE_HEADING];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed.startsWith("export ") || trimmed.startsWith("class ") || trimmed.startsWith("interface ") || trimmed.startsWith("type ") || trimmed.startsWith("function ") || trimmed.startsWith("const ") || trimmed.startsWith("async function ")) {
+      const signature = trimmed.length > MAX_SIGNATURE_LENGTH ? `${trimmed.slice(0, MAX_SIGNATURE_LENGTH)}...` : trimmed;
+      output.push(`Line ${i + 1}: ${signature}`);
+    }
+  }
+  return output.join(`
+`);
+}
+function extractPythonStructure(lines) {
+  const output = [STRUCTURE_HEADING];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed.startsWith("class ") || trimmed.startsWith("def ") || trimmed.startsWith("async def ") || trimmed.startsWith("@")) {
+      const signature = trimmed.length > MAX_SIGNATURE_LENGTH ? `${trimmed.slice(0, MAX_SIGNATURE_LENGTH)}...` : trimmed;
+      output.push(`Line ${i + 1}: ${signature}`);
+    }
+  }
+  return output.join(`
+`);
+}
+function extractGoStructure(lines) {
+  const output = [STRUCTURE_HEADING];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed.startsWith("type ") || trimmed.startsWith("func ") || trimmed.startsWith("package ")) {
+      const signature = trimmed.length > MAX_SIGNATURE_LENGTH ? `${trimmed.slice(0, MAX_SIGNATURE_LENGTH)}...` : trimmed;
+      output.push(`Line ${i + 1}: ${signature}`);
+    }
+  }
+  return output.join(`
+`);
+}
+function extractMarkdownStructure(lines) {
+  const output = [`## Outline
+`];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("#")) {
+      output.push(`Line ${i + 1}: ${line}`);
+    }
+  }
+  return output.join(`
+`);
+}
+function extractJsonStructure(content) {
+  try {
+    const obj = JSON.parse(content);
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+      return "## JSON (non-object top-level value)";
+    }
+    const keys = Object.keys(obj);
+    return `## Top-level keys (${keys.length})
+
+${keys.slice(0, MAX_JSON_KEYS_SHOWN).join(", ")}${keys.length > MAX_JSON_KEYS_SHOWN ? "..." : ""}`;
+  } catch {
+    return "## Invalid JSON";
+  }
+}
+function extractYamlStructure(lines) {
+  const output = [`## Top-level keys
+`];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line.match(/^[a-zA-Z_][a-zA-Z0-9_]*:/)) {
+      output.push(`Line ${i + 1}: ${line}`);
+    }
+  }
+  return output.join(`
+`);
+}
+function extractGenericStructure(lines) {
+  const total = lines.length;
+  const preview = lines.slice(0, MAX_PREVIEW_LINES).join(`
+`);
+  const tail = lines.slice(TAIL_PREVIEW_LINES).join(`
+`);
+  return `## File Preview (${total} lines)
+
+### First ${MAX_PREVIEW_LINES} lines:
+${preview}
+
+### Last ${-TAIL_PREVIEW_LINES} lines:
+${tail}`;
+}
+var lookAtTool = tool({
+  description: `Extract key information from a file to save context tokens.
+For large files, returns structure/outline instead of full content.
+Use when you need to understand a file without loading all content.
+Ideal for: large files, getting file structure, quick overview.`,
+  args: {
+    filePath: tool.schema.string().describe("Path to the file"),
+    extract: tool.schema.string().optional().describe("What to extract: 'structure', 'imports', 'exports', 'all' (default: auto)")
+  },
+  execute: async (args2) => {
+    try {
+      const stats = statSync(args2.filePath);
+      const ext = extname(args2.filePath).toLowerCase();
+      const name = basename(args2.filePath);
+      const content = readFileSync(args2.filePath, "utf-8");
+      const lines = content.split(`
+`);
+      if (stats.size < LARGE_FILE_THRESHOLD && lines.length <= MAX_LINES_WITHOUT_EXTRACT) {
+        return `## ${name} (${lines.length} lines)
+
+${content}`;
+      }
+      let output = `## ${name}
+`;
+      output += `**Size**: ${Math.round(stats.size / BYTES_PER_KB)}KB | **Lines**: ${lines.length}
+
+`;
+      if (EXTRACTABLE_EXTENSIONS.includes(ext)) {
+        output += extractStructure(content, ext);
+      } else {
+        output += extractGenericStructure(lines);
+      }
+      output += `
+
+---
+*Use Read tool with line offset/limit for specific sections*`;
+      return output;
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+});
+
+// src/tools/artifact-search.ts
+async function searchArtifacts(args2) {
+  try {
+    const { spawn } = await import("child_process");
+    return new Promise((resolve, reject) => {
+      const limit = args2.limit ?? 10;
+      const typeFilter = args2.type ?? "all";
+      const proc = spawn("artifact-index", ["search", "--query", args2.query, "--limit", String(limit), "--type", typeFilter], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve(stdout || "No artifacts found matching your query.");
+        } else {
+          reject(new Error(`artifact-index exited with code ${code}: ${stderr}`));
+        }
+      });
+      proc.on("error", (err) => {
+        reject(err);
+      });
+      setTimeout(() => {
+        proc.kill();
+        reject(new Error("artifact-index search timed out"));
+      }, 30000);
+    });
+  } catch (error45) {
+    if (error45 instanceof Error && error45.message.includes("not found")) {
+      return `artifact_search requires artifact-index to be installed:
+      
+1. Install artifact-index CLI:
+   npm install -g artifact-index
+
+2. Initialize the database:
+   artifact-index init
+
+3. Index your artifacts:
+   artifact-index add /path/to/your/code
+
+4. Then search using this tool with your query.
+
+Note: This tool requires the artifact-index npm package to be installed globally.`;
+    }
+    throw error45;
+  }
+}
+var artifactSearchTool = tool({
+  description: "Search through indexed artifacts (code snippets, documents) stored in SQLite. Requires artifact-index npm package to be installed. Use for finding previously indexed code or documentation.",
+  args: {
+    query: tool.schema.string().describe("Search query for artifacts"),
+    limit: tool.schema.number().optional().describe("Maximum number of results to return (default: 10)"),
+    type: tool.schema.enum(["code", "doc", "all"]).optional().describe("Filter by type: code, doc, or all (default: all)")
+  },
+  async execute(args2, _context) {
+    return searchArtifacts(args2);
+  }
+});
+
+// src/tools/btca-ask.ts
+async function btcaAsk(args2) {
+  try {
+    const { spawn } = await import("child_process");
+    return new Promise((resolve, reject) => {
+      const cmdArgs = [args2.command];
+      if (args2.device && ["connect", "disconnect"].includes(args2.command)) {
+        cmdArgs.push(args2.device);
+      }
+      if (args2.value && args2.command === "volume") {
+        cmdArgs.push(args2.value);
+      }
+      const proc = spawn("btca", cmdArgs, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve(stdout || `Command ${args2.command} executed successfully.`);
+        } else {
+          reject(new Error(`btca exited with code ${code}: ${stderr}`));
+        }
+      });
+      proc.on("error", (err) => {
+        reject(err);
+      });
+      setTimeout(() => {
+        proc.kill();
+        reject(new Error("btca command timed out"));
+      }, 1e4);
+    });
+  } catch (error45) {
+    if (error45 instanceof Error && error45.message.includes("not found")) {
+      return `btca_ask requires btca CLI to be installed:
+      
+1. Install btca CLI:
+   npm install -g btca-cli
+
+2. Make sure Bluetooth is enabled on your system
+
+3. Pair your Bluetooth audio device:
+   btca pair
+
+4. List available devices:
+   btca list
+
+5. Connect to a device:
+   btca connect <device-name>
+
+6. Then use this tool to control playback.
+
+Note: This tool requires the btca-cli npm package and Bluetooth hardware.`;
+    }
+    throw error45;
+  }
+}
+var btcaAskTool = tool({
+  description: "Control Bluetooth Classic Audio devices. Requires btca-cli npm package. Use for playing/pausing music, controlling volume, and managing Bluetooth audio connections.",
+  args: {
+    command: tool.schema.enum(["status", "play", "pause", "next", "prev", "volume", "list", "connect", "disconnect"]).describe("Command to execute"),
+    device: tool.schema.string().optional().describe("Device name (required for connect/disconnect commands)"),
+    value: tool.schema.string().optional().describe("Value (e.g., volume level 0-100 for volume command)")
+  },
+  async execute(args2, _context) {
+    return btcaAsk(args2);
+  }
+});
+
+// src/tools/pty.ts
+var ptySessions = new Map;
+async function startPty(args) {
+  try {
+    const bunPty = await eval('import("bun-pty")');
+    const open = bunPty.open;
+    const pty = open({
+      command: args.command,
+      cwd: args.cwd,
+      env: args.env
+    });
+    const id = `pty-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    ptySessions.set(id, {
+      proc: pty,
+      command: args.command,
+      startedAt: new Date
+    });
+    pty.on("data", (data) => {
+      console.log(`[${id}] ${data}`);
+    });
+    return `Started PTY session: ${id}
+Command: ${args.command}
+Working Directory: ${args.cwd ?? process.cwd()}
+
+Use pty_read with id "${id}" to read output, pty_send to send input, and pty_kill to terminate.`;
+  } catch (error45) {
+    if (error45 instanceof Error && (error45.message.includes("not found") || error45.message.includes("MODULE_NOT_FOUND") || error45.message.includes("Cannot find module"))) {
+      return `pty_start requires bun-pty to be installed:
+      
+Option 1 - Use opencode-pty plugin (recommended):
+Add "opencode-pty" to your plugins in opencode.json
+
+Option 2 - Install bun-pty directly:
+npm install -g bun-pty
+
+The PTY tools provide interactive terminal sessions for:
+- Running dev servers in background
+- Interactive programs (REPLs)
+- Long-running processes
+- Watch modes
+
+Note: bun-pty may require native compilation which can fail on some systems.
+The opencode-pty plugin handles this more gracefully.`;
+    }
+    throw error45;
+  }
+}
+async function sendToPty(args2) {
+  const session = ptySessions.get(args2.id);
+  if (!session) {
+    return `No PTY session found with id: ${args2.id}. Use pty_list to see active sessions.`;
+  }
+  if (!session.proc) {
+    return `PTY session ${args2.id} is not running.`;
+  }
+  try {
+    session.proc.write(args2.input);
+    return `Sent to ${args2.id}: ${args2.input}`;
+  } catch (error45) {
+    return `Failed to send input: ${error45 instanceof Error ? error45.message : String(error45)}`;
+  }
+}
+async function readPty(args2) {
+  const session = ptySessions.get(args2.id);
+  if (!session) {
+    return `No PTY session found with id: ${args2.id}. Use pty_list to see active sessions.`;
+  }
+  return `PTY Session: ${args2.id}
+Command: ${session.command}
+Started: ${session.startedAt.toISOString()}
+Status: ${session.proc ? "running" : "stopped"}
+
+Note: Full output streaming requires bun-pty native module.`;
+}
+async function killPty(args2) {
+  const session = ptySessions.get(args2.id);
+  if (!session) {
+    return `No PTY session found with id: ${args2.id}. Use pty_list to see active sessions.`;
+  }
+  try {
+    if (session.proc) {
+      session.proc.kill();
+    }
+    ptySessions.delete(args2.id);
+    return `Killed PTY session: ${args2.id}`;
+  } catch (error45) {
+    ptySessions.delete(args2.id);
+    return `Error killing PTY ${args2.id}: ${error45 instanceof Error ? error45.message : String(error45)}`;
+  }
+}
+async function listPty(_args) {
+  if (ptySessions.size === 0) {
+    return "No active PTY sessions.";
+  }
+  let output = `Active PTY Sessions:
+
+`;
+  for (const [id2, session] of ptySessions) {
+    output += `ID: ${id2}
+`;
+    output += `Command: ${session.command}
+`;
+    output += `Started: ${session.startedAt.toISOString()}
+`;
+    output += `Status: ${session.proc ? "running" : "stopped"}
+`;
+    output += `---
+`;
+  }
+  return output;
+}
+var ptyStartTool = tool({
+  description: "Start a new PTY (pseudo-terminal) session for running interactive processes in background. Requires bun-pty or opencode-pty plugin.",
+  args: {
+    command: tool.schema.string().describe("Command to execute in the PTY"),
+    cwd: tool.schema.string().optional().describe("Working directory for the command"),
+    env: tool.schema.object({}).optional().describe("Environment variables for the command")
+  },
+  async execute(args2, _context) {
+    return startPty(args2);
+  }
+});
+var ptySendTool = tool({
+  description: "Send input to a running PTY session.",
+  args: {
+    id: tool.schema.string().describe("PTY session ID"),
+    input: tool.schema.string().describe("Input to send to the PTY")
+  },
+  async execute(args2, _context) {
+    return sendToPty(args2);
+  }
+});
+var ptyReadTool = tool({
+  description: "Read output from a PTY session.",
+  args: {
+    id: tool.schema.string().describe("PTY session ID"),
+    clear: tool.schema.boolean().optional().describe("Clear the output buffer after reading")
+  },
+  async execute(args2, _context) {
+    return readPty(args2);
+  }
+});
+var ptyKillTool = tool({
+  description: "Kill/terminate a PTY session.",
+  args: {
+    id: tool.schema.string().describe("PTY session ID to kill")
+  },
+  async execute(args2, _context) {
+    return killPty(args2);
+  }
+});
+var ptyListTool = tool({
+  description: "List all active PTY sessions.",
+  args: {},
+  async execute(_args, _context) {
+    return listPty({});
+  }
+});
+
 // src/agents/hive.ts
-var QUEEN_BEE_PROMPT = `# Hive (Hybrid)
+var QUEEN_BEE_PROMPT = `# Zetta (Hybrid)
 
 Hybrid agent: plans AND orchestrates. Phase-aware, skills on-demand.
 
@@ -15687,17 +16473,20 @@ function buildCustomSubagents({
 }
 
 // src/mcp/websearch.ts
+var exaApiKey = process.env.EXA_API_KEY || process.env.OPENCODE_EXA_API_KEY;
 var websearchMcp = {
   type: "remote",
   url: "https://mcp.exa.ai/mcp?tools=web_search_exa",
-  headers: process.env.EXA_API_KEY ? { "x-api-key": process.env.EXA_API_KEY } : undefined,
+  headers: exaApiKey ? { "x-api-key": exaApiKey } : undefined,
   oauth: false
 };
 
 // src/mcp/context7.ts
+var context7ApiKey = process.env.CONTEXT7_API_KEY || process.env.OPENCODE_CONTEXT7_API_KEY;
 var context7Mcp = {
   type: "remote",
   url: "https://mcp.context7.com/mcp",
+  headers: context7ApiKey ? { Authorization: `Bearer ${context7ApiKey}` } : undefined,
   oauth: false
 };
 
@@ -15709,9 +16498,10 @@ var grepAppMcp = {
 };
 
 // src/mcp/ast-grep.ts
-var astGrepMcp = {
-  type: "local",
-  command: ["npx", "-y", "@notprolands/ast-grep-mcp"]
+var astGrepRemoteMcp = {
+  type: "remote",
+  url: "https://mcp.ast-grep.dev/mcp",
+  oauth: false
 };
 
 // src/mcp/index.ts
@@ -15719,7 +16509,7 @@ var allBuiltinMcps = {
   websearch: websearchMcp,
   context7: context7Mcp,
   grep_app: grepAppMcp,
-  ast_grep: astGrepMcp
+  ast_grep: astGrepRemoteMcp
 };
 var createBuiltinMcps = (disabledMcps = []) => {
   const disabled = new Set(disabledMcps);
@@ -15920,7 +16710,7 @@ var require_common = __commonJS((exports, module) => {
       let enableOverride = null;
       let namespacesCache;
       let enabledCache;
-      function debug(...args) {
+      function debug(...args2) {
         if (!debug.enabled) {
           return;
         }
@@ -15931,28 +16721,28 @@ var require_common = __commonJS((exports, module) => {
         self.prev = prevTime;
         self.curr = curr;
         prevTime = curr;
-        args[0] = createDebug.coerce(args[0]);
-        if (typeof args[0] !== "string") {
-          args.unshift("%O");
+        args2[0] = createDebug.coerce(args2[0]);
+        if (typeof args2[0] !== "string") {
+          args2.unshift("%O");
         }
         let index = 0;
-        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+        args2[0] = args2[0].replace(/%([a-zA-Z%])/g, (match, format) => {
           if (match === "%%") {
             return "%";
           }
           index++;
           const formatter = createDebug.formatters[format];
           if (typeof formatter === "function") {
-            const val = args[index];
+            const val = args2[index];
             match = formatter.call(self, val);
-            args.splice(index, 1);
+            args2.splice(index, 1);
             index--;
           }
           return match;
         });
-        createDebug.formatArgs.call(self, args);
+        createDebug.formatArgs.call(self, args2);
         const logFn = self.log || createDebug.log;
-        logFn.apply(self, args);
+        logFn.apply(self, args2);
       }
       debug.namespace = namespace;
       debug.useColors = createDebug.useColors();
@@ -16166,16 +16956,16 @@ var require_browser = __commonJS((exports, module) => {
     let m;
     return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
   }
-  function formatArgs(args) {
-    args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+  function formatArgs(args2) {
+    args2[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args2[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
     if (!this.useColors) {
       return;
     }
     const c = "color: " + this.color;
-    args.splice(1, 0, c, "color: inherit");
+    args2.splice(1, 0, c, "color: inherit");
     let index = 0;
     let lastC = 0;
-    args[0].replace(/%[a-zA-Z%]/g, (match) => {
+    args2[0].replace(/%[a-zA-Z%]/g, (match) => {
       if (match === "%%") {
         return;
       }
@@ -16184,7 +16974,7 @@ var require_browser = __commonJS((exports, module) => {
         lastC = index;
       }
     });
-    args.splice(lastC, 0, c);
+    args2.splice(lastC, 0, c);
   }
   exports.log = console.debug || console.log || (() => {});
   function save(namespaces) {
@@ -16339,18 +17129,18 @@ var require_node = __commonJS((exports, module) => {
   function useColors() {
     return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
   }
-  function formatArgs(args) {
+  function formatArgs(args2) {
     const { namespace: name, useColors: useColors2 } = this;
     if (useColors2) {
       const c = this.color;
       const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
       const prefix = `  ${colorCode};1m${name} \x1B[0m`;
-      args[0] = prefix + args[0].split(`
+      args2[0] = prefix + args2[0].split(`
 `).join(`
 ` + prefix);
-      args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+      args2.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
     } else {
-      args[0] = getDate() + name + " " + args[0];
+      args2[0] = getDate() + name + " " + args2[0];
     }
   }
   function getDate() {
@@ -16359,8 +17149,8 @@ var require_node = __commonJS((exports, module) => {
     }
     return new Date().toISOString() + " ";
   }
-  function log(...args) {
-    return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + `
+  function log(...args2) {
+    return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args2) + `
 `);
   }
   function save(namespaces) {
@@ -16485,7 +17275,7 @@ var require_dist2 = __commonJS((exports) => {
   exports.default = deferred;
 });
 var BUILT_IN_AGENT_NAMES = [
-  "hive",
+  "zetta",
   "architect-planner",
   "swarm-orchestrator",
   "scout-researcher",
@@ -16507,7 +17297,7 @@ var CUSTOM_AGENT_RESERVED_NAMES = [
   "code"
 ];
 var DEFAULT_AGENT_MODELS = {
-  hive: "github-copilot/claude-opus-4.5",
+  zetta: "github-copilot/claude-opus-4.5",
   "architect-planner": "github-copilot/gpt-5.2-codex",
   "swarm-orchestrator": "github-copilot/claude-opus-4.5",
   "scout-researcher": "zai-coding-plan/glm-4.7",
@@ -16537,27 +17327,22 @@ var DEFAULT_HIVE_CONFIG = {
     }
   },
   agents: {
-    hive: {
-      model: DEFAULT_AGENT_MODELS["hive"],
+    zetta: {
+      model: DEFAULT_AGENT_MODELS["zetta"],
       temperature: 0.5,
-      skills: [
-        "brainstorming",
-        "writing-plans",
-        "dispatching-parallel-agents",
-        "executing-plans"
-      ],
+      skills: [],
       autoLoadSkills: ["parallel-exploration"]
     },
     "architect-planner": {
       model: DEFAULT_AGENT_MODELS["architect-planner"],
       temperature: 0.7,
-      skills: ["brainstorming", "writing-plans"],
+      skills: [],
       autoLoadSkills: ["parallel-exploration"]
     },
     "swarm-orchestrator": {
       model: DEFAULT_AGENT_MODELS["swarm-orchestrator"],
       temperature: 0.5,
-      skills: ["dispatching-parallel-agents", "executing-plans"],
+      skills: [],
       autoLoadSkills: []
     },
     "scout-researcher": {
@@ -16574,7 +17359,7 @@ var DEFAULT_HIVE_CONFIG = {
     "hygienic-reviewer": {
       model: DEFAULT_AGENT_MODELS["hygienic-reviewer"],
       temperature: 0.3,
-      skills: ["systematic-debugging", "code-reviewer"],
+      skills: [],
       autoLoadSkills: []
     }
   }
@@ -17576,7 +18361,7 @@ var __defProp22 = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames2 = Object.getOwnPropertyNames;
 var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
+var __esm2 = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
 };
 var __commonJS2 = (cb, mod) => function __require22() {
@@ -17607,13 +18392,13 @@ function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
 }
 var cache;
-var init_pathspec = __esm({
+var init_pathspec = __esm2({
   "src/lib/args/pathspec.ts"() {
     cache = /* @__PURE__ */ new WeakMap;
   }
 });
 var GitError;
-var init_git_error = __esm({
+var init_git_error = __esm2({
   "src/lib/errors/git-error.ts"() {
     GitError = class extends Error {
       constructor(task, message) {
@@ -17625,7 +18410,7 @@ var init_git_error = __esm({
   }
 });
 var GitResponseError;
-var init_git_response_error = __esm({
+var init_git_response_error = __esm2({
   "src/lib/errors/git-response-error.ts"() {
     init_git_error();
     GitResponseError = class extends GitError {
@@ -17637,7 +18422,7 @@ var init_git_response_error = __esm({
   }
 });
 var TaskConfigurationError;
-var init_task_configuration_error = __esm({
+var init_task_configuration_error = __esm2({
   "src/lib/errors/task-configuration-error.ts"() {
     init_git_error();
     TaskConfigurationError = class extends GitError {
@@ -17768,7 +18553,7 @@ function orVoid(input) {
 var NULL;
 var NOOP;
 var objectToString;
-var init_util = __esm({
+var init_util = __esm2({
   "src/lib/utils/util.ts"() {
     init_argument_filters();
     NULL = "\x00";
@@ -17797,7 +18582,7 @@ var filterNumber;
 var filterString;
 var filterStringOrStringArray;
 var filterHasLength;
-var init_argument_filters = __esm({
+var init_argument_filters = __esm2({
   "src/lib/utils/argument-filters.ts"() {
     init_pathspec();
     init_util();
@@ -17822,7 +18607,7 @@ var init_argument_filters = __esm({
   }
 });
 var ExitCodes;
-var init_exit_codes = __esm({
+var init_exit_codes = __esm2({
   "src/lib/utils/exit-codes.ts"() {
     ExitCodes = /* @__PURE__ */ ((ExitCodes2) => {
       ExitCodes2[ExitCodes2["SUCCESS"] = 0] = "SUCCESS";
@@ -17834,7 +18619,7 @@ var init_exit_codes = __esm({
   }
 });
 var GitOutputStreams;
-var init_git_output_streams = __esm({
+var init_git_output_streams = __esm2({
   "src/lib/utils/git-output-streams.ts"() {
     GitOutputStreams = class _GitOutputStreams {
       constructor(stdOut, stdErr) {
@@ -17852,7 +18637,7 @@ function useMatchesDefault() {
 }
 var LineParser;
 var RemoteLineParser;
-var init_line_parser = __esm({
+var init_line_parser = __esm2({
   "src/lib/utils/line-parser.ts"() {
     LineParser = class {
       constructor(regExp, useMatches) {
@@ -17907,7 +18692,7 @@ function createInstanceConfig(...options) {
   return config2;
 }
 var defaultOptions;
-var init_simple_git_options = __esm({
+var init_simple_git_options = __esm2({
   "src/lib/utils/simple-git-options.ts"() {
     defaultOptions = {
       binary: "git",
@@ -17939,32 +18724,32 @@ function appendTaskOptions(options, commands = []) {
     return commands2;
   }, commands);
 }
-function getTrailingOptions(args, initialPrimitive = 0, objectOnly = false) {
+function getTrailingOptions(args2, initialPrimitive = 0, objectOnly = false) {
   const command = [];
-  for (let i = 0, max = initialPrimitive < 0 ? args.length : initialPrimitive;i < max; i++) {
-    if ("string|number".includes(typeof args[i])) {
-      command.push(String(args[i]));
+  for (let i = 0, max = initialPrimitive < 0 ? args2.length : initialPrimitive;i < max; i++) {
+    if ("string|number".includes(typeof args2[i])) {
+      command.push(String(args2[i]));
     }
   }
-  appendTaskOptions(trailingOptionsArgument(args), command);
+  appendTaskOptions(trailingOptionsArgument(args2), command);
   if (!objectOnly) {
-    command.push(...trailingArrayArgument(args));
+    command.push(...trailingArrayArgument(args2));
   }
   return command;
 }
-function trailingArrayArgument(args) {
-  const hasTrailingCallback = typeof last(args) === "function";
-  return asStringArray(filterType(last(args, hasTrailingCallback ? 1 : 0), filterArray, []));
+function trailingArrayArgument(args2) {
+  const hasTrailingCallback = typeof last(args2) === "function";
+  return asStringArray(filterType(last(args2, hasTrailingCallback ? 1 : 0), filterArray, []));
 }
-function trailingOptionsArgument(args) {
-  const hasTrailingCallback = filterFunction(last(args));
-  return filterType(last(args, hasTrailingCallback ? 1 : 0), filterPlainObject);
+function trailingOptionsArgument(args2) {
+  const hasTrailingCallback = filterFunction(last(args2));
+  return filterType(last(args2, hasTrailingCallback ? 1 : 0), filterPlainObject);
 }
-function trailingFunctionArgument(args, includeNoop = true) {
-  const callback = asFunction(last(args));
+function trailingFunctionArgument(args2, includeNoop = true) {
+  const callback = asFunction(last(args2));
   return includeNoop || isUserFunction(callback) ? callback : undefined;
 }
-var init_task_options = __esm({
+var init_task_options = __esm2({
   "src/lib/utils/task-options.ts"() {
     init_argument_filters();
     init_util();
@@ -17988,7 +18773,7 @@ function parseStringResponse(result, parsers12, texts, trim = true) {
   });
   return result;
 }
-var init_task_parser = __esm({
+var init_task_parser = __esm2({
   "src/lib/utils/task-parser.ts"() {
     init_util();
   }
@@ -18039,7 +18824,7 @@ __export2(utils_exports, {
   trailingFunctionArgument: () => trailingFunctionArgument,
   trailingOptionsArgument: () => trailingOptionsArgument
 });
-var init_utils = __esm({
+var init_utils = __esm2({
   "src/lib/utils/index.ts"() {
     init_argument_filters();
     init_exit_codes();
@@ -18099,7 +18884,7 @@ function isNotRepoMessage(error45) {
 var CheckRepoActions;
 var onError;
 var parser;
-var init_check_is_repo = __esm({
+var init_check_is_repo = __esm2({
   "src/lib/tasks/check-is-repo.ts"() {
     init_utils();
     CheckRepoActions = /* @__PURE__ */ ((CheckRepoActions2) => {
@@ -18133,7 +18918,7 @@ var CleanResponse;
 var removalRegexp;
 var dryRunRemovalRegexp;
 var isFolderRegexp;
-var init_CleanSummary = __esm({
+var init_CleanSummary = __esm2({
   "src/lib/responses/CleanSummary.ts"() {
     init_utils();
     CleanResponse = class {
@@ -18200,7 +18985,7 @@ function isEmptyTask(task) {
   return task.format === "empty" || !task.commands.length;
 }
 var EMPTY_COMMANDS;
-var init_task = __esm({
+var init_task = __esm2({
   "src/lib/tasks/task.ts"() {
     init_task_configuration_error();
     EMPTY_COMMANDS = [];
@@ -18278,7 +19063,7 @@ var CONFIG_ERROR_MODE_REQUIRED;
 var CONFIG_ERROR_UNKNOWN_OPTION;
 var CleanOptions;
 var CleanOptionValues;
-var init_clean = __esm({
+var init_clean = __esm2({
   "src/lib/tasks/clean.ts"() {
     init_CleanSummary();
     init_utils();
@@ -18351,7 +19136,7 @@ function* configParser(text, requestedKey = null) {
   }
 }
 var ConfigList;
-var init_ConfigList = __esm({
+var init_ConfigList = __esm2({
   "src/lib/responses/ConfigList.ts"() {
     init_utils();
     ConfigList = class {
@@ -18449,7 +19234,7 @@ function config_default() {
   };
 }
 var GitConfigScope;
-var init_config = __esm({
+var init_config = __esm2({
   "src/lib/tasks/config.ts"() {
     init_ConfigList();
     init_utils();
@@ -18467,7 +19252,7 @@ function isDiffNameStatus(input) {
 }
 var DiffNameStatus;
 var diffNameStatus;
-var init_diff_name_status = __esm({
+var init_diff_name_status = __esm2({
   "src/lib/tasks/diff-name-status.ts"() {
     DiffNameStatus = /* @__PURE__ */ ((DiffNameStatus2) => {
       DiffNameStatus2["ADDED"] = "A";
@@ -18532,7 +19317,7 @@ var disallowedOptions;
 var Query;
 var _a;
 var GrepQuery;
-var init_grep = __esm({
+var init_grep = __esm2({
   "src/lib/tasks/grep.ts"() {
     init_utils();
     init_task();
@@ -18588,7 +19373,7 @@ function isValidResetMode(mode) {
 }
 var ResetMode;
 var validResetModes;
-var init_reset = __esm({
+var init_reset = __esm2({
   "src/lib/tasks/reset.ts"() {
     init_utils();
     init_task();
@@ -18608,15 +19393,15 @@ function createLog() {
 }
 function prefixedLogger(to, prefix, forward) {
   if (!prefix || !String(prefix).replace(/\s*/, "")) {
-    return !forward ? to : (message, ...args) => {
-      to(message, ...args);
-      forward(message, ...args);
+    return !forward ? to : (message, ...args2) => {
+      to(message, ...args2);
+      forward(message, ...args2);
     };
   }
-  return (message, ...args) => {
-    to(`%s ${message}`, prefix, ...args);
+  return (message, ...args2) => {
+    to(`%s ${message}`, prefix, ...args2);
     if (forward) {
-      forward(message, ...args);
+      forward(message, ...args2);
     }
   };
 }
@@ -18651,7 +19436,7 @@ function createLogger(label, verbose, initialStep, infoDebugger = createLog()) {
     });
   }
 }
-var init_git_logger = __esm({
+var init_git_logger = __esm2({
   "src/lib/git-logger.ts"() {
     init_utils();
     import_debug.default.formatters.L = (value) => String(filterHasLength(value) ? value.length : "-");
@@ -18664,7 +19449,7 @@ var init_git_logger = __esm({
   }
 });
 var TasksPendingQueue;
-var init_tasks_pending_queue = __esm({
+var init_tasks_pending_queue = __esm2({
   "src/lib/runners/tasks-pending-queue.ts"() {
     init_git_error();
     init_git_logger();
@@ -18748,7 +19533,7 @@ function onDataReceived(target, name, logger, output) {
   };
 }
 var GitExecutorChain;
-var init_git_executor_chain = __esm({
+var init_git_executor_chain = __esm2({
   "src/lib/runners/git-executor-chain.ts"() {
     init_git_error();
     init_task();
@@ -18802,9 +19587,9 @@ var init_git_executor_chain = __esm({
       }
       async attemptRemoteTask(task, logger) {
         const binary = this._plugins.exec("spawn.binary", "", pluginContext(task, task.commands));
-        const args = this._plugins.exec("spawn.args", [...task.commands], pluginContext(task, task.commands));
-        const raw = await this.gitResponse(task, binary, args, this.outputHandler, logger.step("SPAWN"));
-        const outputStreams = await this.handleTaskData(task, args, raw, logger.step("HANDLE"));
+        const args2 = this._plugins.exec("spawn.args", [...task.commands], pluginContext(task, task.commands));
+        const raw = await this.gitResponse(task, binary, args2, this.outputHandler, logger.step("SPAWN"));
+        const outputStreams = await this.handleTaskData(task, args2, raw, logger.step("HANDLE"));
         logger(`passing response to task's parser as a %s`, task.format);
         if (isBufferTask(task)) {
           return callTaskParser(task.parser, outputStreams);
@@ -18815,12 +19600,12 @@ var init_git_executor_chain = __esm({
         logger(`empty task bypassing child process to call to task's parser`);
         return task.parser(this);
       }
-      handleTaskData(task, args, result, logger) {
+      handleTaskData(task, args2, result, logger) {
         const { exitCode, rejection, stdOut, stdErr } = result;
         return new Promise((done, fail) => {
           logger(`Preparing to handle process response exitCode=%d stdOut=`, exitCode);
           const { error: error45 } = this._plugins.exec("task.error", { error: rejection }, {
-            ...pluginContext(task, args),
+            ...pluginContext(task, args2),
             ...result
           });
           if (error45 && task.onError) {
@@ -18839,7 +19624,7 @@ var init_git_executor_chain = __esm({
           done(new GitOutputStreams(Buffer.concat(stdOut), Buffer.concat(stdErr)));
         });
       }
-      async gitResponse(task, command, args, outputHandler, logger) {
+      async gitResponse(task, command, args2, outputHandler, logger) {
         const outputLogger = logger.sibling("output");
         const spawnOptions = this._plugins.exec("spawn.options", {
           cwd: this.cwd,
@@ -18849,9 +19634,9 @@ var init_git_executor_chain = __esm({
         return new Promise((done) => {
           const stdOut = [];
           const stdErr = [];
-          logger.info(`%s %o`, command, args);
+          logger.info(`%s %o`, command, args2);
           logger("%O", spawnOptions);
-          let rejection = this._beforeSpawn(task, args);
+          let rejection = this._beforeSpawn(task, args2);
           if (rejection) {
             return done({
               stdOut,
@@ -18861,21 +19646,21 @@ var init_git_executor_chain = __esm({
             });
           }
           this._plugins.exec("spawn.before", undefined, {
-            ...pluginContext(task, args),
+            ...pluginContext(task, args2),
             kill(reason) {
               rejection = reason || rejection;
             }
           });
-          const spawned = spawn(command, args, spawnOptions);
+          const spawned = spawn(command, args2, spawnOptions);
           spawned.stdout.on("data", onDataReceived(stdOut, "stdOut", logger, outputLogger.step("stdOut")));
           spawned.stderr.on("data", onDataReceived(stdErr, "stdErr", logger, outputLogger.step("stdErr")));
           spawned.on("error", onErrorReceived(stdErr, logger));
           if (outputHandler) {
             logger(`Passing child process stdOut/stdErr to custom outputHandler`);
-            outputHandler(command, spawned.stdout, spawned.stderr, [...args]);
+            outputHandler(command, spawned.stdout, spawned.stderr, [...args2]);
           }
           this._plugins.exec("spawn.after", undefined, {
-            ...pluginContext(task, args),
+            ...pluginContext(task, args2),
             spawned,
             close(exitCode, reason) {
               done({
@@ -18895,10 +19680,10 @@ var init_git_executor_chain = __esm({
           });
         });
       }
-      _beforeSpawn(task, args) {
+      _beforeSpawn(task, args2) {
         let rejection;
         this._plugins.exec("spawn.before", undefined, {
-          ...pluginContext(task, args),
+          ...pluginContext(task, args2),
           kill(reason) {
             rejection = reason || rejection;
           }
@@ -18913,7 +19698,7 @@ __export2(git_executor_exports, {
   GitExecutor: () => GitExecutor
 });
 var GitExecutor;
-var init_git_executor = __esm({
+var init_git_executor = __esm2({
   "src/lib/runners/git-executor.ts"() {
     init_git_executor_chain();
     GitExecutor = class {
@@ -18964,7 +19749,7 @@ function addDeprecationNoticeToError(err) {
     return all;
   }
 }
-var init_task_callback = __esm({
+var init_task_callback = __esm2({
   "src/lib/task-callback.ts"() {
     init_git_response_error();
     init_utils();
@@ -18978,14 +19763,14 @@ function changeWorkingDirectoryTask(directory, root) {
     return (root || instance).cwd = directory;
   });
 }
-var init_change_working_directory = __esm({
+var init_change_working_directory = __esm2({
   "src/lib/tasks/change-working-directory.ts"() {
     init_utils();
     init_task();
   }
 });
-function checkoutTask(args) {
-  const commands = ["checkout", ...args];
+function checkoutTask(args2) {
+  const commands = ["checkout", ...args2];
   if (commands[1] === "-b" && commands.includes("-B")) {
     commands[1] = remove(commands, "-B");
   }
@@ -19004,7 +19789,7 @@ function checkout_default() {
     }
   };
 }
-var init_checkout = __esm({
+var init_checkout = __esm2({
   "src/lib/tasks/checkout.ts"() {
     init_utils();
     init_task();
@@ -19036,7 +19821,7 @@ function count_objects_default() {
   };
 }
 var parser2;
-var init_count_objects = __esm({
+var init_count_objects = __esm2({
   "src/lib/tasks/count-objects.ts"() {
     init_utils();
     parser2 = new LineParser(/([a-z-]+): (\d+)$/, (result, [key, value]) => {
@@ -19062,7 +19847,7 @@ function parseCommitResult(stdOut) {
   return parseStringResponse(result, parsers, stdOut);
 }
 var parsers;
-var init_parse_commit = __esm({
+var init_parse_commit = __esm2({
   "src/lib/parsers/parse-commit.ts"() {
     init_utils();
     parsers = [
@@ -19129,7 +19914,7 @@ function commit_default() {
     return !filterStringOrStringArray(message) && configurationErrorTask(`git.commit: requires the commit message to be supplied as a string/string[]`);
   }
 }
-var init_commit = __esm({
+var init_commit = __esm2({
   "src/lib/tasks/commit.ts"() {
     init_parse_commit();
     init_utils();
@@ -19143,7 +19928,7 @@ function first_commit_default() {
     }
   };
 }
-var init_first_commit = __esm({
+var init_first_commit = __esm2({
   "src/lib/tasks/first-commit.ts"() {
     init_utils();
     init_task();
@@ -19156,7 +19941,7 @@ function hashObjectTask(filePath, write) {
   }
   return straightThroughStringTask(commands, true);
 }
-var init_hash_object = __esm({
+var init_hash_object = __esm2({
   "src/lib/tasks/hash-object.ts"() {
     init_task();
   }
@@ -19184,7 +19969,7 @@ function parseInit(bare, path32, text) {
 var InitSummary;
 var initResponseRegex;
 var reInitResponseRegex;
-var init_InitSummary = __esm({
+var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     InitSummary = class {
       constructor(bare, path32, existing, gitDir) {
@@ -19215,7 +20000,7 @@ function initTask(bare = false, path32, customArgs) {
   };
 }
 var bareCommand;
-var init_init = __esm({
+var init_init = __esm2({
   "src/lib/tasks/init.ts"() {
     init_InitSummary();
     bareCommand = "--bare";
@@ -19234,13 +20019,13 @@ function isLogFormat(customArg) {
   return logFormatRegex.test(customArg);
 }
 var logFormatRegex;
-var init_log_format = __esm({
+var init_log_format = __esm2({
   "src/lib/args/log-format.ts"() {
     logFormatRegex = /^--(stat|numstat|name-only|name-status)(=|$)/;
   }
 });
 var DiffSummary;
-var init_DiffSummary = __esm({
+var init_DiffSummary = __esm2({
   "src/lib/responses/DiffSummary.ts"() {
     DiffSummary = class {
       constructor() {
@@ -19261,7 +20046,7 @@ var numStatParser;
 var nameOnlyParser;
 var nameStatusParser;
 var diffSummaryParsers;
-var init_parse_diff_summary = __esm({
+var init_parse_diff_summary = __esm2({
   "src/lib/parsers/parse-diff-summary.ts"() {
     init_log_format();
     init_DiffSummary();
@@ -19382,7 +20167,7 @@ var START_BOUNDARY;
 var COMMIT_BOUNDARY;
 var SPLITTER;
 var defaultFieldNames;
-var init_parse_list_log_summary = __esm({
+var init_parse_list_log_summary = __esm2({
   "src/lib/parsers/parse-list-log-summary.ts"() {
     init_utils();
     init_parse_diff_summary();
@@ -19421,7 +20206,7 @@ function validateLogFormatConfig(customArgs) {
     return configurationErrorTask(`Summary flag ${flags} parsing is not compatible with null termination option '-z'`);
   }
 }
-var init_diff = __esm({
+var init_diff = __esm2({
   "src/lib/tasks/diff.ts"() {
     init_log_format();
     init_parse_diff_summary();
@@ -19505,7 +20290,7 @@ function log_default() {
   }
 }
 var excludeOptions;
-var init_log = __esm({
+var init_log = __esm2({
   "src/lib/tasks/log.ts"() {
     init_log_format();
     init_pathspec();
@@ -19533,7 +20318,7 @@ var init_log = __esm({
 });
 var MergeSummaryConflict;
 var MergeSummaryDetail;
-var init_MergeSummary = __esm({
+var init_MergeSummary = __esm2({
   "src/lib/responses/MergeSummary.ts"() {
     MergeSummaryConflict = class {
       constructor(reason, file2 = null, meta) {
@@ -19568,7 +20353,7 @@ var init_MergeSummary = __esm({
 });
 var PullSummary;
 var PullFailedSummary;
-var init_PullSummary = __esm({
+var init_PullSummary = __esm2({
   "src/lib/responses/PullSummary.ts"() {
     PullSummary = class {
       constructor() {
@@ -19625,7 +20410,7 @@ function asObjectCount(source) {
   };
 }
 var remoteMessagesObjectParsers;
-var init_parse_remote_objects = __esm({
+var init_parse_remote_objects = __esm2({
   "src/lib/parsers/parse-remote-objects.ts"() {
     init_utils();
     remoteMessagesObjectParsers = [
@@ -19653,7 +20438,7 @@ function parseRemoteMessages(_stdOut, stdErr) {
 }
 var parsers2;
 var RemoteMessageSummary;
-var init_parse_remote_messages = __esm({
+var init_parse_remote_messages = __esm2({
   "src/lib/parsers/parse-remote-messages.ts"() {
     init_utils();
     init_parse_remote_objects();
@@ -19692,7 +20477,7 @@ var parsers3;
 var errorParsers;
 var parsePullDetail;
 var parsePullResult;
-var init_parse_pull = __esm({
+var init_parse_pull = __esm2({
   "src/lib/parsers/parse-pull.ts"() {
     init_PullSummary();
     init_utils();
@@ -19745,7 +20530,7 @@ var init_parse_pull = __esm({
 var parsers4;
 var parseMergeResult;
 var parseMergeDetail;
-var init_parse_merge = __esm({
+var init_parse_merge = __esm2({
   "src/lib/parsers/parse-merge.ts"() {
     init_MergeSummary();
     init_utils();
@@ -19791,7 +20576,7 @@ function mergeTask(customArgs) {
     }
   };
 }
-var init_merge = __esm({
+var init_merge = __esm2({
   "src/lib/tasks/merge.ts"() {
     init_git_response_error();
     init_parse_merge();
@@ -19815,7 +20600,7 @@ function pushResultPushedItem(local, remote, status) {
 var parsers5;
 var parsePushResult;
 var parsePushDetail;
-var init_parse_push = __esm({
+var init_parse_push = __esm2({
   "src/lib/parsers/parse-push.ts"() {
     init_utils();
     init_parse_remote_messages();
@@ -19892,7 +20677,7 @@ function pushTask(ref = {}, customArgs) {
     parser: parsePushResult
   };
 }
-var init_push = __esm({
+var init_push = __esm2({
   "src/lib/tasks/push.ts"() {
     init_parse_push();
     init_utils();
@@ -19913,7 +20698,7 @@ function show_default() {
     }
   };
 }
-var init_show = __esm({
+var init_show = __esm2({
   "src/lib/tasks/show.ts"() {
     init_utils();
     init_task();
@@ -19921,7 +20706,7 @@ var init_show = __esm({
 });
 var fromPathRegex;
 var FileStatusSummary;
-var init_FileStatusSummary = __esm({
+var init_FileStatusSummary = __esm2({
   "src/lib/responses/FileStatusSummary.ts"() {
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
@@ -19975,7 +20760,7 @@ function splitLine(result, lineStr) {
 var StatusSummary;
 var parsers6;
 var parseStatusSummary;
-var init_StatusSummary = __esm({
+var init_StatusSummary = __esm2({
   "src/lib/responses/StatusSummary.ts"() {
     init_utils();
     init_FileStatusSummary();
@@ -20099,7 +20884,7 @@ function statusTask(customArgs) {
   };
 }
 var ignoredOptions;
-var init_status = __esm({
+var init_status = __esm2({
   "src/lib/tasks/status.ts"() {
     init_StatusSummary();
     ignoredOptions = ["--null", "-z"];
@@ -20148,7 +20933,7 @@ function versionParser(stdOut) {
 }
 var NOT_INSTALLED;
 var parsers7;
-var init_version = __esm({
+var init_version = __esm2({
   "src/lib/tasks/version.ts"() {
     init_utils();
     NOT_INSTALLED = "installed=false";
@@ -20162,11 +20947,11 @@ var init_version = __esm({
     ];
   }
 });
-function createCloneTask(api2, task, repoPath, ...args) {
+function createCloneTask(api2, task, repoPath, ...args2) {
   if (!filterString(repoPath)) {
     return configurationErrorTask(`git.${api2}() requires a string 'repoPath'`);
   }
-  return task(repoPath, filterType(args[0], filterString), getTrailingOptions(arguments));
+  return task(repoPath, filterType(args2[0], filterString), getTrailingOptions(arguments));
 }
 function clone_default() {
   return {
@@ -20180,7 +20965,7 @@ function clone_default() {
 }
 var cloneTask;
 var cloneMirrorTask;
-var init_clone = __esm({
+var init_clone = __esm2({
   "src/lib/tasks/clone.ts"() {
     init_task();
     init_utils();
@@ -20202,7 +20987,7 @@ __export2(simple_git_api_exports, {
   SimpleGitApi: () => SimpleGitApi
 });
 var SimpleGitApi;
-var init_simple_git_api = __esm({
+var init_simple_git_api = __esm2({
   "src/lib/simple-git-api.ts"() {
     init_task_callback();
     init_change_working_directory();
@@ -20294,19 +21079,19 @@ __export2(scheduler_exports, {
 });
 var createScheduledTask;
 var Scheduler;
-var init_scheduler = __esm({
+var init_scheduler = __esm2({
   "src/lib/runners/scheduler.ts"() {
     init_utils();
     init_git_logger();
     createScheduledTask = /* @__PURE__ */ (() => {
-      let id = 0;
+      let id2 = 0;
       return () => {
-        id++;
+        id2++;
         const { promise: promise2, done } = import_promise_deferred.createDeferred();
         return {
           promise: promise2,
           done,
-          id
+          id: id2
         };
       };
     })();
@@ -20332,8 +21117,8 @@ var init_scheduler = __esm({
         });
       }
       next() {
-        const { promise: promise2, id } = append(this.pending, createScheduledTask());
-        this.logger(`Scheduling id=%s`, id);
+        const { promise: promise2, id: id2 } = append(this.pending, createScheduledTask());
+        this.logger(`Scheduling id=%s`, id2);
         this.schedule();
         return promise2;
       }
@@ -20347,7 +21132,7 @@ __export2(apply_patch_exports, {
 function applyPatchTask(patches, customArgs) {
   return straightThroughStringTask(["apply", ...customArgs, ...patches]);
 }
-var init_apply_patch = __esm({
+var init_apply_patch = __esm2({
   "src/lib/tasks/apply-patch.ts"() {
     init_task();
   }
@@ -20367,7 +21152,7 @@ function branchDeletionFailure(branch) {
   };
 }
 var BranchDeletionBatch;
-var init_BranchDeleteSummary = __esm({
+var init_BranchDeleteSummary = __esm2({
   "src/lib/responses/BranchDeleteSummary.ts"() {
     BranchDeletionBatch = class {
       constructor() {
@@ -20388,7 +21173,7 @@ var deleteSuccessRegex;
 var deleteErrorRegex;
 var parsers8;
 var parseBranchDeletions;
-var init_parse_branch_delete = __esm({
+var init_parse_branch_delete = __esm2({
   "src/lib/parsers/parse-branch-delete.ts"() {
     init_BranchDeleteSummary();
     init_utils();
@@ -20413,7 +21198,7 @@ var init_parse_branch_delete = __esm({
   }
 });
 var BranchSummaryResult;
-var init_BranchSummary = __esm({
+var init_BranchSummary = __esm2({
   "src/lib/responses/BranchSummary.ts"() {
     BranchSummaryResult = class {
       constructor() {
@@ -20447,7 +21232,7 @@ function parseBranchSummary(stdOut, currentOnly = false) {
 }
 var parsers9;
 var currentBranchParser;
-var init_parse_branch = __esm({
+var init_parse_branch = __esm2({
   "src/lib/parsers/parse-branch.ts"() {
     init_BranchSummary();
     init_utils();
@@ -20537,7 +21322,7 @@ function deleteBranchTask(branch, forceDelete = false) {
   };
   return task;
 }
-var init_branch = __esm({
+var init_branch = __esm2({
   "src/lib/tasks/branch.ts"() {
     init_git_response_error();
     init_parse_branch_delete();
@@ -20550,7 +21335,7 @@ function toPath(input) {
   return path32 && normalize(path32);
 }
 var parseCheckIgnore;
-var init_CheckIgnore = __esm({
+var init_CheckIgnore = __esm2({
   "src/lib/responses/CheckIgnore.ts"() {
     parseCheckIgnore = (text) => {
       return text.split(/\n/g).map(toPath).filter(Boolean);
@@ -20568,7 +21353,7 @@ function checkIgnoreTask(paths) {
     parser: parseCheckIgnore
   };
 }
-var init_check_ignore = __esm({
+var init_check_ignore = __esm2({
   "src/lib/tasks/check-ignore.ts"() {
     init_CheckIgnore();
   }
@@ -20585,7 +21370,7 @@ function parseFetchResult(stdOut, stdErr) {
   return parseStringResponse(result, parsers10, [stdOut, stdErr]);
 }
 var parsers10;
-var init_parse_fetch = __esm({
+var init_parse_fetch = __esm2({
   "src/lib/parsers/parse-fetch.ts"() {
     init_utils();
     parsers10 = [
@@ -20642,7 +21427,7 @@ function fetchTask(remote, branch, customArgs) {
     parser: parseFetchResult
   };
 }
-var init_fetch = __esm({
+var init_fetch = __esm2({
   "src/lib/tasks/fetch.ts"() {
     init_parse_fetch();
     init_task();
@@ -20652,7 +21437,7 @@ function parseMoveResult(stdOut) {
   return parseStringResponse({ moves: [] }, parsers11, stdOut);
 }
 var parsers11;
-var init_parse_move = __esm({
+var init_parse_move = __esm2({
   "src/lib/parsers/parse-move.ts"() {
     init_utils();
     parsers11 = [
@@ -20673,7 +21458,7 @@ function moveTask(from, to) {
     parser: parseMoveResult
   };
 }
-var init_move = __esm({
+var init_move = __esm2({
   "src/lib/tasks/move.ts"() {
     init_parse_move();
     init_utils();
@@ -20703,7 +21488,7 @@ function pullTask(remote, branch, customArgs) {
     }
   };
 }
-var init_pull = __esm({
+var init_pull = __esm2({
   "src/lib/tasks/pull.ts"() {
     init_git_response_error();
     init_parse_pull();
@@ -20733,7 +21518,7 @@ function parseGetRemotesVerbose(text) {
 function forEach(text, handler) {
   forEachLineWithContent(text, (line) => handler(line.split(/\s+/)));
 }
-var init_GetRemoteSummary = __esm({
+var init_GetRemoteSummary = __esm2({
   "src/lib/responses/GetRemoteSummary.ts"() {
     init_utils();
   }
@@ -20777,7 +21562,7 @@ function remoteTask(customArgs) {
 function removeRemoteTask(remoteName) {
   return straightThroughStringTask(["remote", "remove", remoteName]);
 }
-var init_remote = __esm({
+var init_remote = __esm2({
   "src/lib/tasks/remote.ts"() {
     init_GetRemoteSummary();
     init_task();
@@ -20797,7 +21582,7 @@ function stashListTask(opt = {}, customArgs) {
     parser: parser4
   };
 }
-var init_stash_list = __esm({
+var init_stash_list = __esm2({
   "src/lib/tasks/stash-list.ts"() {
     init_log_format();
     init_parse_list_log_summary();
@@ -20828,7 +21613,7 @@ function subModuleTask(customArgs) {
 function updateSubModuleTask(customArgs) {
   return subModuleTask(["update", ...customArgs]);
 }
-var init_sub_module = __esm({
+var init_sub_module = __esm2({
   "src/lib/tasks/sub-module.ts"() {
     init_task();
   }
@@ -20855,7 +21640,7 @@ function toNumber(input) {
 }
 var TagList;
 var parseTagList;
-var init_TagList = __esm({
+var init_TagList = __esm2({
   "src/lib/responses/TagList.ts"() {
     TagList = class {
       constructor(all, latest) {
@@ -20921,7 +21706,7 @@ function addAnnotatedTagTask(name, tagMessage) {
     }
   };
 }
-var init_tag = __esm({
+var init_tag = __esm2({
   "src/lib/tasks/tag.ts"() {
     init_TagList();
   }
@@ -21070,10 +21855,10 @@ var require_git = __commonJS2({
     Git2.prototype.submoduleAdd = function(repo, path32, then) {
       return this._runTask(addSubModuleTask2(repo, path32), trailingFunctionArgument2(arguments));
     };
-    Git2.prototype.submoduleUpdate = function(args, then) {
+    Git2.prototype.submoduleUpdate = function(args2, then) {
       return this._runTask(updateSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
     };
-    Git2.prototype.submoduleInit = function(args, then) {
+    Git2.prototype.submoduleInit = function(args2, then) {
       return this._runTask(initSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.subModule = function(options, then) {
@@ -21120,10 +21905,10 @@ var require_git = __commonJS2({
     Git2.prototype.binaryCatFile = function() {
       return this._catFile("buffer", arguments);
     };
-    Git2.prototype._catFile = function(format, args) {
-      var handler = trailingFunctionArgument2(args);
+    Git2.prototype._catFile = function(format, args2) {
+      var handler = trailingFunctionArgument2(args2);
       var command = ["cat-file"];
-      var options = args[0];
+      var options = args2[0];
       if (typeof options === "string") {
         return this._runTask(configurationErrorTask2("Git.catFile: options must be supplied as an array of strings"), handler);
       }
@@ -21270,13 +22055,13 @@ function blockUnsafeOperationsPlugin({
 } = {}) {
   return {
     type: "spawn.args",
-    action(args, context) {
-      args.forEach((current, index) => {
-        const next = index < args.length ? args[index + 1] : "";
+    action(args2, context) {
+      args2.forEach((current, index) => {
+        const next = index < args2.length ? args2[index + 1] : "";
         allowUnsafePack || preventUploadPack(current, context.method);
         preventUnsafeConfig.forEach((helper) => helper(options, current, next));
       });
-      return args;
+      return args2;
     }
   };
 }
@@ -21484,11 +22269,11 @@ function progressMonitorPlugin(progress) {
   };
   const onArgs = {
     type: "spawn.args",
-    action(args, context) {
+    action(args2, context) {
       if (!progressMethods.includes(context.method)) {
-        return args;
+        return args2;
       }
-      return including(args, progressCommand);
+      return including(args2, progressCommand);
     }
   };
   return [onArgs, onProgress];
@@ -21547,8 +22332,8 @@ function suffixPathsPlugin() {
     action(data) {
       const prefix = [];
       let suffix;
-      function append2(args) {
-        (suffix = suffix || []).push(...args);
+      function append2(args2) {
+        (suffix = suffix || []).push(...args2);
       }
       for (let i = 0;i < data.length; i++) {
         const param = data[i];
@@ -22219,11 +23004,12 @@ class ConfigService {
     return this.get();
   }
   getAgentConfig(agent) {
+    const resolvedAgent = agent === "hive" ? "zetta" : agent;
     const config2 = this.get();
-    if (this.isBuiltInAgent(agent)) {
-      const agentConfig = config2.agents?.[agent] ?? {};
-      const defaultAutoLoadSkills = DEFAULT_HIVE_CONFIG.agents?.[agent]?.autoLoadSkills ?? [];
-      const effectiveAutoLoadSkills = this.resolveAutoLoadSkills(defaultAutoLoadSkills, agentConfig.autoLoadSkills ?? [], this.isPlannerAgent(agent));
+    if (this.isBuiltInAgent(resolvedAgent)) {
+      const agentConfig = config2.agents?.[resolvedAgent] ?? {};
+      const defaultAutoLoadSkills = DEFAULT_HIVE_CONFIG.agents?.[resolvedAgent]?.autoLoadSkills ?? [];
+      const effectiveAutoLoadSkills = this.resolveAutoLoadSkills(defaultAutoLoadSkills, agentConfig.autoLoadSkills ?? [], this.isPlannerAgent(resolvedAgent));
       return {
         ...agentConfig,
         autoLoadSkills: effectiveAutoLoadSkills
@@ -22297,7 +23083,7 @@ class ConfigService {
     return CUSTOM_AGENT_BASES.includes(baseAgent);
   }
   isPlannerAgent(agent) {
-    return agent === "hive" || agent === "architect-planner";
+    return agent === "zetta" || agent === "architect-planner";
   }
   isObjectRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -23282,7 +24068,7 @@ var plugin = async (ctx) => {
   const disabledSkills = configService.getDisabledSkills();
   const builtinMcps = createBuiltinMcps(disabledMcps);
   const filteredSkills = getFilteredSkills(disabledSkills);
-  const effectiveAutoLoadSkills = configService.getAgentConfig("hive").autoLoadSkills ?? [];
+  const effectiveAutoLoadSkills = configService.getAgentConfig("zetta").autoLoadSkills ?? [];
   const worktreeService = new WorktreeService({
     baseDir: directory,
     hiveDir: path8.join(directory, ".hive")
@@ -23773,8 +24559,31 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
         }
       }
     },
-    "experimental.session.compacting": async (_input, output) => {
-      output.context.push(buildCompactionPrompt());
+    "experimental.session.compacting": async (input, output) => {
+      const contextLimit = input.contextLimit || 200000;
+      const messages = input.messages || [];
+      if (messages.length > 0) {
+        const { estimateTokens: estimateTokens2, needsCompression: needsCompression2, compressContext: compressContext2, buildCompressionHint: buildCompressionHint2 } = await Promise.resolve().then(() => (init_context_compression(), exports_context_compression));
+        if (needsCompression2(messages, contextLimit, { threshold: 0.5, enabled: true })) {
+          const { compressed, stats } = compressContext2(messages, {
+            threshold: 0.5,
+            enabled: true,
+            maxToolCalls: 50,
+            protectedTools: [
+              "hive_feature_create",
+              "hive_plan_write",
+              "hive_worktree_commit",
+              "hive_merge"
+            ]
+          }, contextLimit);
+          console.log(`[hive:compaction] Context at ${Math.round(stats.reductionRatio * 100)}% - compressed ${stats.originalMessages} → ${stats.compressedMessages} messages`);
+          output.context.push(buildCompressionHint2());
+        } else {
+          output.context.push(buildCompactionPrompt());
+        }
+      } else {
+        output.context.push(buildCompactionPrompt());
+      }
     },
     "chat.message": createVariantHook(configService),
     "tool.execute.before": async (input, output) => {
@@ -23807,6 +24616,15 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
     },
     mcp: builtinMcps,
     tool: {
+      gitingest: gitingestTool,
+      look_at: lookAtTool,
+      artifact_search: artifactSearchTool,
+      btca_ask: btcaAskTool,
+      pty_start: ptyStartTool,
+      pty_send: ptySendTool,
+      pty_read: ptyReadTool,
+      pty_kill: ptyKillTool,
+      pty_list: ptyListTool,
       hive_skill: createHiveSkillTool(filteredSkills),
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",
@@ -24418,8 +25236,8 @@ ${result.diff}
     command: {
       hive: {
         description: "Create a new feature: /hive <feature-name>",
-        async run(args) {
-          const name = args.trim();
+        async run(args2) {
+          const name = args2.trim();
           if (!name)
             return "Usage: /hive <feature-name>";
           return `Create feature "${name}" using hive_feature_create tool.`;
@@ -24464,14 +25282,14 @@ ${result.diff}
 ## Configured Custom Subagents
 ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompare(right)).map(([name, config2]) => `- \`${name}\` — derived from \`${config2.baseAgent}\`; ${config2.description}`).join(`
 `)}`;
-      const hiveUserConfig = configService.getAgentConfig("hive");
-      const hiveAutoLoadedSkills = await buildAutoLoadedSkillsContent("hive", configService, directory);
-      const hiveConfig = {
-        model: hiveUserConfig.model,
-        variant: hiveUserConfig.variant,
-        temperature: hiveUserConfig.temperature ?? 0.5,
-        description: "Hive (Hybrid) - Plans + orchestrates. Detects phase, loads skills on-demand.",
-        prompt: QUEEN_BEE_PROMPT + hiveAutoLoadedSkills + (agentMode === "unified" ? customSubagentAppendix : ""),
+      const zettaUserConfig = configService.getAgentConfig("zetta");
+      const zettaAutoLoadedSkills = await buildAutoLoadedSkillsContent("zetta", configService, directory);
+      const zettaConfig = {
+        model: zettaUserConfig.model,
+        variant: zettaUserConfig.variant,
+        temperature: zettaUserConfig.temperature ?? 0.5,
+        description: "Zetta (Hybrid) - Plans + orchestrates. Detects phase, loads skills on-demand.",
+        prompt: QUEEN_BEE_PROMPT + zettaAutoLoadedSkills + (agentMode === "unified" ? customSubagentAppendix : ""),
         permission: {
           question: "allow",
           skill: "allow",
@@ -24582,7 +25400,7 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         }
       };
       const builtInAgentConfigs = {
-        hive: hiveConfig,
+        zetta: zettaConfig,
         "architect-planner": architectConfig,
         "swarm-orchestrator": swarmConfig,
         "scout-researcher": scoutConfig,
@@ -24607,7 +25425,7 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
       });
       const allAgents = {};
       if (agentMode === "unified") {
-        allAgents["hive"] = builtInAgentConfigs["hive"];
+        allAgents["zetta"] = builtInAgentConfigs["zetta"];
         allAgents["scout-researcher"] = builtInAgentConfigs["scout-researcher"];
         allAgents["forager-worker"] = builtInAgentConfigs["forager-worker"];
         allAgents["hygienic-reviewer"] = builtInAgentConfigs["hygienic-reviewer"];
@@ -24636,14 +25454,31 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         delete configAgent["scout-researcher"];
         delete configAgent["forager-worker"];
         delete configAgent["hygienic-reviewer"];
+        if (configAgent.build) {
+          configAgent.build.mode = "subagent";
+        }
+        if (configAgent.plan) {
+          configAgent.plan.mode = "subagent";
+        }
+        if (configAgent.triage) {
+          configAgent.triage.mode = "subagent";
+        }
+        if (configAgent.docs) {
+          configAgent.docs.mode = "subagent";
+        }
         Object.assign(configAgent, allAgents);
       }
-      opencodeConfig.default_agent = agentMode === "unified" ? "hive" : "architect-planner";
+      opencodeConfig.default_agent = agentMode === "unified" ? "zetta" : "architect-planner";
       const configMcp = opencodeConfig.mcp;
+      const mcpToAdd = builtinMcps;
       if (!configMcp) {
-        opencodeConfig.mcp = builtinMcps;
+        opencodeConfig.mcp = mcpToAdd;
       } else {
-        Object.assign(configMcp, builtinMcps);
+        for (const [name, config2] of Object.entries(mcpToAdd)) {
+          if (!(name in configMcp)) {
+            configMcp[name] = config2;
+          }
+        }
       }
     }
   };