opencode-gitbutler 0.1.0

package/dist/index.js

@@ -0,0 +1,1731 @@
+// @bun
+// src/config.ts
+import { resolve } from "path";
+var DEFAULT_CONFIG = {
+  log_enabled: true,
+  commit_message_model: "claude-haiku-4-5",
+  commit_message_provider: "anthropic",
+  llm_timeout_ms: 15000,
+  max_diff_chars: 4000,
+  branch_slug_max_length: 50,
+  auto_update: true,
+  default_branch_pattern: "^ge-branch-\\d+$",
+  stale_lock_ms: 300000,
+  edit_debounce_ms: 200,
+  gc_on_session_start: false,
+  notification_max_age_ms: 300000
+};
+var CONFIG_FILE_NAME = ".opencode/gitbutler.json";
+function stripJsonComments(input) {
+  let result = "";
+  let i = 0;
+  const len = input.length;
+  while (i < len) {
+    const ch = input[i];
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < len) {
+        if (input[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (input[j] === '"') {
+          j++;
+          break;
+        }
+        j++;
+      }
+      result += input.slice(i, j);
+      i = j;
+      continue;
+    }
+    if (ch === "/" && i + 1 < len && input[i + 1] === "/") {
+      i += 2;
+      while (i < len && input[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (ch === "/" && i + 1 < len && input[i + 1] === "*") {
+      const closeIdx = input.indexOf("*/", i + 2);
+      i = closeIdx !== -1 ? closeIdx + 2 : len;
+      continue;
+    }
+    result += ch;
+    i++;
+  }
+  result = result.replace(/,\s*([\]}])/g, "$1");
+  return result;
+}
+function isValidRegex(pattern) {
+  if (typeof pattern !== "string")
+    return false;
+  try {
+    new RegExp(pattern);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadConfig(cwd) {
+  const configPath = resolve(cwd, CONFIG_FILE_NAME);
+  try {
+    const file = Bun.file(configPath);
+    if (!await file.exists()) {
+      return { ...DEFAULT_CONFIG };
+    }
+    const raw = await file.text();
+    const cleaned = stripJsonComments(raw);
+    const parsed = JSON.parse(cleaned);
+    return {
+      log_enabled: typeof parsed.log_enabled === "boolean" ? parsed.log_enabled : DEFAULT_CONFIG.log_enabled,
+      commit_message_model: typeof parsed.commit_message_model === "string" ? parsed.commit_message_model : DEFAULT_CONFIG.commit_message_model,
+      commit_message_provider: typeof parsed.commit_message_provider === "string" ? parsed.commit_message_provider : DEFAULT_CONFIG.commit_message_provider,
+      llm_timeout_ms: typeof parsed.llm_timeout_ms === "number" && parsed.llm_timeout_ms > 0 ? parsed.llm_timeout_ms : DEFAULT_CONFIG.llm_timeout_ms,
+      max_diff_chars: typeof parsed.max_diff_chars === "number" && parsed.max_diff_chars > 0 ? parsed.max_diff_chars : DEFAULT_CONFIG.max_diff_chars,
+      branch_slug_max_length: typeof parsed.branch_slug_max_length === "number" && parsed.branch_slug_max_length > 0 ? parsed.branch_slug_max_length : DEFAULT_CONFIG.branch_slug_max_length,
+      auto_update: typeof parsed.auto_update === "boolean" ? parsed.auto_update : DEFAULT_CONFIG.auto_update,
+      default_branch_pattern: isValidRegex(parsed.default_branch_pattern) ? parsed.default_branch_pattern : DEFAULT_CONFIG.default_branch_pattern,
+      stale_lock_ms: typeof parsed.stale_lock_ms === "number" && parsed.stale_lock_ms > 0 ? parsed.stale_lock_ms : DEFAULT_CONFIG.stale_lock_ms,
+      edit_debounce_ms: typeof parsed.edit_debounce_ms === "number" && parsed.edit_debounce_ms >= 0 ? parsed.edit_debounce_ms : DEFAULT_CONFIG.edit_debounce_ms,
+      gc_on_session_start: typeof parsed.gc_on_session_start === "boolean" ? parsed.gc_on_session_start : DEFAULT_CONFIG.gc_on_session_start,
+      notification_max_age_ms: typeof parsed.notification_max_age_ms === "number" && parsed.notification_max_age_ms >= 0 ? parsed.notification_max_age_ms : DEFAULT_CONFIG.notification_max_age_ms,
+      ...typeof parsed.branch_target === "string" && parsed.branch_target.length > 0 ? { branch_target: parsed.branch_target } : {}
+    };
+  } catch (err) {
+    console.warn(`[opencode-gitbutler] Failed to parse config at ${configPath}: ${err instanceof Error ? err.message : String(err)}. Using defaults.`);
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+// src/logger.ts
+import { appendFile } from "fs/promises";
+var LOG_PATH_SUFFIX = ".opencode/plugin/debug.log";
+function createLogger(logEnabled, cwd) {
+  function write(level, cat, data = {}) {
+    if (!logEnabled)
+      return;
+    const entry = {
+      ts: new Date().toISOString(),
+      level,
+      cat,
+      ...data
+    };
+    appendFile(`${cwd}/${LOG_PATH_SUFFIX}`, JSON.stringify(entry) + `
+`).catch(() => {});
+  }
+  return {
+    info: (cat, data) => write("info", cat, data ?? {}),
+    warn: (cat, data) => write("warn", cat, data ?? {}),
+    error: (cat, data) => write("error", cat, data ?? {})
+  };
+}
+
+// src/cli.ts
+import { resolve as resolve2, relative } from "path";
+var CURSOR_RETRY_PARAMS = {
+  stop: { maxRetries: 5, baseMs: 500 },
+  default: { maxRetries: 3, baseMs: 200 }
+};
+function createCli(cwd, log) {
+  const resolvedCwd = resolve2(cwd);
+  function toRelativePath(absPath) {
+    const resolved = resolve2(absPath);
+    const rel = relative(resolvedCwd, resolved);
+    if (rel.startsWith(".."))
+      return absPath;
+    return rel;
+  }
+  function isWorkspaceMode() {
+    try {
+      const proc = Bun.spawnSync(["git", "symbolic-ref", "--short", "HEAD"], { cwd, stdout: "pipe", stderr: "pipe" });
+      if (proc.exitCode !== 0)
+        return false;
+      return proc.stdout.toString().trim() === "gitbutler/workspace";
+    } catch {
+      return false;
+    }
+  }
+  function findFileBranch(filePath, statusData) {
+    try {
+      let data;
+      if (statusData) {
+        data = statusData;
+      } else {
+        const proc = Bun.spawnSync(["but", "status", "--json", "-f"], { cwd, stdout: "pipe", stderr: "pipe" });
+        if (proc.exitCode !== 0)
+          return { inBranch: false };
+        data = JSON.parse(proc.stdout.toString());
+      }
+      const normalized = toRelativePath(filePath);
+      const unassigned = data.unassignedChanges?.find((ch) => ch.filePath === normalized);
+      for (const stack of data.stacks ?? []) {
+        if (stack.assignedChanges?.some((ch) => ch.filePath === normalized)) {
+          return { inBranch: true };
+        }
+        for (const branch of stack.branches ?? []) {
+          for (const commit of branch.commits ?? []) {
+            if (commit.changes?.some((ch) => ch.filePath === normalized)) {
+              return {
+                inBranch: true,
+                branchCliId: branch.cliId,
+                branchName: branch.name,
+                unassignedCliId: unassigned?.cliId
+              };
+            }
+          }
+        }
+      }
+      return { inBranch: false };
+    } catch {
+      return { inBranch: false };
+    }
+  }
+  function butRub(source, dest) {
+    try {
+      const proc = Bun.spawnSync(["but", "rub", source, dest], { cwd, stdout: "pipe", stderr: "pipe" });
+      return proc.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+  function butUnapply(branchCliId) {
+    try {
+      const proc = Bun.spawnSync(["but", "unapply", branchCliId], { cwd, stdout: "pipe", stderr: "pipe" });
+      return {
+        ok: proc.exitCode === 0,
+        stderr: proc.stderr?.toString().trim() ?? ""
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        stderr: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async function butUnapplyWithRetry(branchCliId, branchName, maxRetries = 4) {
+    let lastStderr = "";
+    for (let attempt = 0;attempt <= maxRetries; attempt++) {
+      if (attempt > 0) {
+        const status = getFullStatus();
+        if (status?.stacks) {
+          const branch = status.stacks.flatMap((s) => s.branches ?? []).find((b) => b.cliId === branchCliId);
+          if (!branch) {
+            log.info("cleanup-ok", {
+              branch: branchName,
+              retries: attempt,
+              reason: "branch-gone"
+            });
+            return true;
+          }
+          if (branch.commits.length > 0) {
+            log.info("cleanup-skipped", {
+              branch: branchName,
+              retries: attempt,
+              reason: "branch-has-commits",
+              commitCount: branch.commits.length
+            });
+            return true;
+          }
+        }
+      }
+      const result = butUnapply(branchCliId);
+      if (result.ok) {
+        log.info("cleanup-ok", {
+          branch: branchName,
+          ...attempt > 0 ? { retries: attempt } : {}
+        });
+        return true;
+      }
+      lastStderr = result.stderr;
+      const isLocked = lastStderr.includes("locked") || lastStderr.includes("SQLITE_BUSY") || lastStderr.includes("database is locked");
+      const isNotFound = lastStderr.includes("not found") || lastStderr.includes("Branch not found");
+      if (isNotFound) {
+        log.info("cleanup-ok", {
+          branch: branchName,
+          retries: attempt,
+          reason: "not-found"
+        });
+        return true;
+      }
+      if (attempt < maxRetries) {
+        const delay = 500 * 2 ** attempt;
+        log.info("cleanup-retry", {
+          branch: branchName,
+          attempt: attempt + 1,
+          delayMs: delay,
+          reason: isLocked ? "locked" : "unknown",
+          stderr: lastStderr.slice(0, 200)
+        });
+        await Bun.sleep(delay);
+      }
+    }
+    log.error("cleanup-failed", {
+      branch: branchName,
+      attempts: maxRetries + 1,
+      stderr: lastStderr.slice(0, 500),
+      reason: lastStderr.includes("locked") ? "locked" : "unknown"
+    });
+    return false;
+  }
+  function getFullStatus() {
+    try {
+      const proc = Bun.spawnSync(["but", "status", "--json", "-f"], { cwd, stdout: "pipe", stderr: "pipe" });
+      if (proc.exitCode !== 0)
+        return null;
+      return JSON.parse(proc.stdout.toString());
+    } catch {
+      return null;
+    }
+  }
+  function butReword(target, message) {
+    try {
+      const proc = Bun.spawnSync(["but", "reword", target, "-m", message], { cwd, stdout: "pipe", stderr: "pipe" });
+      return {
+        ok: proc.exitCode === 0,
+        stderr: proc.stderr?.toString().trim() ?? ""
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        stderr: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async function butCursor(subcommand, payload) {
+    const json = JSON.stringify(payload);
+    const retryParams = CURSOR_RETRY_PARAMS[subcommand] ?? CURSOR_RETRY_PARAMS.default;
+    for (let attempt = 0;attempt <= retryParams.maxRetries; attempt++) {
+      const proc = Bun.spawn(["but", "cursor", subcommand], {
+        cwd,
+        stdout: "ignore",
+        stderr: "pipe",
+        stdin: new Blob([json])
+      });
+      const exitCode = await proc.exited;
+      if (exitCode === 0) {
+        log.info("cursor-ok", {
+          subcommand,
+          conversationId: payload.conversation_id,
+          ...attempt > 0 ? { retries: attempt } : {}
+        });
+        return;
+      }
+      const stderr = await new Response(proc.stderr).text();
+      const isExpectedError = stderr.includes("not in workspace mode") || stderr.includes("not initialized") || stderr.includes("No such file or directory") || stderr.includes("No hunk headers") || stderr.includes("no changes") || stderr.includes("checkout gitbutler/workspace");
+      if (isExpectedError)
+        return;
+      const isRecoverableRace = stderr.includes("Stack not found") || stderr.includes("reference mismatch") || stderr.includes("Branch not found") || stderr.includes("workspace reference");
+      if (isRecoverableRace) {
+        log.warn("cursor-race", {
+          subcommand,
+          exitCode,
+          stderr: stderr.trim(),
+          attempt,
+          conversationId: payload.conversation_id
+        });
+        return;
+      }
+      const isRetryable = stderr.includes("database is locked") || stderr.includes("SQLITE_BUSY") || stderr.includes("failed to lock file");
+      if (isRetryable && attempt < retryParams.maxRetries) {
+        const delay = retryParams.baseMs * 2 ** attempt;
+        await Bun.sleep(delay);
+        continue;
+      }
+      log.error("cursor-error", {
+        subcommand,
+        exitCode,
+        stderr: stderr.trim(),
+        attempt
+      });
+      throw new Error(`but cursor ${subcommand} failed (exit ${exitCode}): ${stderr.trim()}`);
+    }
+  }
+  function extractFilePath(output) {
+    return output.metadata?.filediff?.file ?? output.metadata?.filepath ?? undefined;
+  }
+  function extractEdits(output) {
+    const fd = output.metadata?.filediff;
+    if (fd?.before != null && fd?.after != null) {
+      return [
+        { old_string: fd.before, new_string: fd.after }
+      ];
+    }
+    return [];
+  }
+  function hasMultiBranchHunks(filePath, statusData) {
+    try {
+      let data;
+      if (statusData) {
+        data = statusData;
+      } else {
+        const proc = Bun.spawnSync(["but", "status", "--json", "-f"], { cwd, stdout: "pipe", stderr: "pipe" });
+        if (proc.exitCode !== 0)
+          return false;
+        data = JSON.parse(proc.stdout.toString());
+      }
+      let branchCount = 0;
+      for (const stack of data.stacks ?? []) {
+        for (const branch of stack.branches ?? []) {
+          const hasInBranch = branch.commits?.some((c) => c.changes?.some((ch) => ch.filePath === filePath));
+          if (hasInBranch)
+            branchCount++;
+          if (branchCount > 1)
+            return true;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  return {
+    isWorkspaceMode,
+    findFileBranch,
+    butRub,
+    butUnapply,
+    butUnapplyWithRetry,
+    getFullStatus,
+    butReword,
+    butCursor,
+    extractFilePath,
+    extractEdits,
+    hasMultiBranchHunks,
+    toRelativePath
+  };
+}
+
+// src/state.ts
+var SUBAGENT_TOOLS = new Set([
+  "agent",
+  "task",
+  "delegate_task"
+]);
+function createStateManager(cwd, log) {
+  const SESSION_MAP_PATH = `${cwd}/.opencode/plugin/session-map.json`;
+  const PLUGIN_STATE_PATH = `${cwd}/.opencode/plugin/plugin-state.json`;
+  const parentSessionByTaskSession = new Map;
+  async function loadPluginState() {
+    try {
+      const file = Bun.file(PLUGIN_STATE_PATH);
+      if (!await file.exists())
+        return {
+          conversationsWithEdits: [],
+          rewordedBranches: [],
+          branchOwnership: {}
+        };
+      const state = await file.json();
+      return {
+        ...state,
+        branchOwnership: state.branchOwnership ?? {}
+      };
+    } catch {
+      return {
+        conversationsWithEdits: [],
+        rewordedBranches: [],
+        branchOwnership: {}
+      };
+    }
+  }
+  async function savePluginState(conversations, reworded, ownership) {
+    const state = {
+      conversationsWithEdits: [...conversations],
+      rewordedBranches: [...reworded],
+      branchOwnership: Object.fromEntries(ownership)
+    };
+    await Bun.write(PLUGIN_STATE_PATH, JSON.stringify(state, null, 2) + `
+`);
+  }
+  async function loadSessionMap() {
+    try {
+      const file = Bun.file(SESSION_MAP_PATH);
+      if (!await file.exists())
+        return new Map;
+      const data = await file.json();
+      return new Map(Object.entries(data));
+    } catch {
+      return new Map;
+    }
+  }
+  async function saveSessionMap(map) {
+    await Bun.write(SESSION_MAP_PATH, JSON.stringify(Object.fromEntries(map), null, 2) + `
+`);
+  }
+  function resolveSessionRoot(sessionID) {
+    if (!sessionID)
+      return "opencode-default";
+    const seen = new Set;
+    let current = sessionID;
+    while (true) {
+      if (seen.has(current))
+        return current;
+      seen.add(current);
+      const parent = parentSessionByTaskSession.get(current);
+      if (!parent)
+        return current;
+      current = parent;
+    }
+  }
+  async function trackSubagentMapping(input, output) {
+    const tool = input.tool;
+    const parentSessionID = input.sessionID;
+    const taskCallID = input.callID;
+    if (!tool || !SUBAGENT_TOOLS.has(tool))
+      return;
+    if (!parentSessionID)
+      return;
+    if (taskCallID) {
+      parentSessionByTaskSession.set(taskCallID, parentSessionID);
+    }
+    const metadata = output?.metadata;
+    const executionSessionId = typeof metadata?.sessionId === "string" ? metadata.sessionId : typeof metadata?.session_id === "string" ? metadata.session_id : undefined;
+    if (executionSessionId && executionSessionId !== parentSessionID) {
+      parentSessionByTaskSession.set(executionSessionId, parentSessionID);
+      log.info("session-map-execution", {
+        executionSession: executionSessionId,
+        parent: parentSessionID,
+        callID: taskCallID
+      });
+    }
+    try {
+      await saveSessionMap(parentSessionByTaskSession);
+    } catch (err) {
+      log.warn("session-map-save-failed", {
+        task: taskCallID,
+        parent: parentSessionID,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    log.info("session-map-subagent", {
+      task: taskCallID,
+      parent: parentSessionID
+    });
+  }
+  async function trackSessionCreatedMapping(event) {
+    if (event.type !== "session.created")
+      return;
+    const properties = event.properties;
+    if (!properties)
+      return;
+    const info = properties.info;
+    const sessionID = (typeof info?.id === "string" ? info.id : undefined) ?? (typeof properties.id === "string" ? properties.id : undefined);
+    const parentSessionID = (typeof info?.parentID === "string" ? info.parentID : undefined) ?? (typeof properties.parentSessionID === "string" ? properties.parentSessionID : typeof properties.parent_session_id === "string" ? properties.parent_session_id : undefined);
+    if (!sessionID || !parentSessionID)
+      return;
+    parentSessionByTaskSession.set(sessionID, parentSessionID);
+    try {
+      await saveSessionMap(parentSessionByTaskSession);
+    } catch (err) {
+      log.warn("session-map-save-failed", {
+        session: sessionID,
+        parent: parentSessionID,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    log.info("session-map-created", {
+      session: sessionID,
+      parent: parentSessionID
+    });
+  }
+  return {
+    loadPluginState,
+    savePluginState,
+    loadSessionMap,
+    saveSessionMap,
+    resolveSessionRoot,
+    trackSubagentMapping,
+    trackSessionCreatedMapping,
+    parentSessionByTaskSession
+  };
+}
+
+// src/notify.ts
+function createNotificationManager(log, resolveSessionRoot, maxAgeMs = 300000) {
+  const pendingNotifications = new Map;
+  function reapExpired() {
+    if (maxAgeMs <= 0)
+      return;
+    const now = Date.now();
+    for (const [rootID, notifications] of pendingNotifications) {
+      const expired = notifications.filter((n) => now - n.timestamp > maxAgeMs);
+      if (expired.length > 0) {
+        for (const n of expired) {
+          log.warn("notification-expired", {
+            rootID,
+            message: n.message,
+            ageMs: now - n.timestamp
+          });
+        }
+        const remaining = notifications.filter((n) => now - n.timestamp <= maxAgeMs);
+        if (remaining.length === 0) {
+          pendingNotifications.delete(rootID);
+        } else {
+          pendingNotifications.set(rootID, remaining);
+        }
+      }
+    }
+  }
+  function addNotification(sessionID, message) {
+    reapExpired();
+    const rootID = resolveSessionRoot(sessionID);
+    const existing = pendingNotifications.get(rootID) ?? [];
+    existing.push({
+      message,
+      timestamp: Date.now()
+    });
+    pendingNotifications.set(rootID, existing);
+    log.info("notification-queued", {
+      rootID,
+      message
+    });
+  }
+  function consumeNotifications(sessionID) {
+    const rootID = resolveSessionRoot(sessionID);
+    const notifications = pendingNotifications.get(rootID);
+    if (!notifications || notifications.length === 0)
+      return null;
+    const now = Date.now();
+    const live = maxAgeMs > 0 ? notifications.filter((n) => {
+      const expired = now - n.timestamp > maxAgeMs;
+      if (expired) {
+        log.warn("notification-expired", {
+          rootID,
+          message: n.message,
+          ageMs: now - n.timestamp
+        });
+      }
+      return !expired;
+    }) : notifications;
+    pendingNotifications.delete(rootID);
+    if (live.length === 0)
+      return null;
+    const lines = live.map((n) => `- ${n.message}`).join(`
+`);
+    return [
+      "<system-reminder>",
+      "[GITBUTLER STATE UPDATE]",
+      "The following happened automatically since your last response:",
+      "",
+      lines,
+      "",
+      "This is informational \u2014 no action needed unless relevant to your current task.",
+      "</system-reminder>"
+    ].join(`
+`);
+  }
+  return { addNotification, consumeNotifications };
+}
+
+// src/reword.ts
+var COMMIT_PREFIX_PATTERNS = [
+  {
+    pattern: /\b(fix|bug|broken|repair|patch)\b/i,
+    prefix: "fix"
+  },
+  {
+    pattern: /\b(add|create|implement|new|feature)\b/i,
+    prefix: "feat"
+  },
+  {
+    pattern: /\b(refactor|clean|restructure|reorganize)\b/i,
+    prefix: "refactor"
+  },
+  {
+    pattern: /\b(test|spec|coverage)\b/i,
+    prefix: "test"
+  },
+  {
+    pattern: /\b(doc|readme|documentation)\b/i,
+    prefix: "docs"
+  },
+  {
+    pattern: /\b(style|css|design|ui|layout)\b/i,
+    prefix: "style"
+  },
+  {
+    pattern: /\b(perf|performance|optimize|speed)\b/i,
+    prefix: "perf"
+  }
+];
+function detectCommitPrefix(text) {
+  for (const {
+    pattern,
+    prefix
+  } of COMMIT_PREFIX_PATTERNS) {
+    if (pattern.test(text))
+      return prefix;
+  }
+  return "chore";
+}
+function toCommitMessage(prompt) {
+  const firstLine = prompt.split(`
+`)[0]?.trim() ?? "";
+  if (!firstLine)
+    return "chore: OpenCode session changes";
+  const prefix = detectCommitPrefix(firstLine);
+  const description = firstLine.replace(/^(fix|feat|refactor|test|docs|style|perf|chore)(\(.+?\))?:\s*/i, "").trim();
+  const maxLen = 72 - prefix.length - 2;
+  const truncated = description.length > maxLen ? description.slice(0, maxLen - 3) + "..." : description;
+  return `${prefix}: ${truncated || "OpenCode session changes"}`;
+}
+function toBranchSlug(prompt, maxLength) {
+  const cleaned = prompt.replace(/[^a-zA-Z0-9\s-]/g, "").trim().toLowerCase().split(/\s+/).slice(0, 6).join("-");
+  return cleaned.slice(0, maxLength) || "opencode-session";
+}
+function classifyRewordFailure(stderr) {
+  if (stderr.includes("locked") || stderr.includes("SQLITE_BUSY"))
+    return "locked";
+  if (stderr.includes("not found") || stderr.includes("Branch not found"))
+    return "not-found";
+  if (stderr.includes("reference mismatch") || stderr.includes("workspace reference"))
+    return "reference-mismatch";
+  if (stderr.includes("not in workspace mode") || stderr.includes("not initialized"))
+    return "not-workspace";
+  return "unknown";
+}
+function createRewordManager(deps) {
+  const {
+    cwd,
+    log,
+    cli,
+    config,
+    defaultBranchPattern,
+    addNotification,
+    resolveSessionRoot,
+    conversationsWithEdits,
+    rewordedBranches,
+    branchOwnership,
+    editedFilesPerConversation,
+    savePluginState,
+    internalSessionIds,
+    reapStaleLocks,
+    client
+  } = deps;
+  const LLM_TIMEOUT_MS = config.llm_timeout_ms;
+  const MAX_DIFF_CHARS = config.max_diff_chars;
+  async function fetchUserPrompt(sessionID) {
+    try {
+      const res = await client.session.messages({
+        path: { id: sessionID },
+        query: { limit: 5 }
+      });
+      if (!res.data)
+        return null;
+      for (const msg of res.data) {
+        if (msg.info.role !== "user")
+          continue;
+        const textPart = msg.parts.find((p) => p.type === "text");
+        if (textPart?.text)
+          return textPart.text;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async function generateLLMCommitMessage(commitId, userPrompt) {
+    try {
+      log.info("llm-start", {
+        commitId,
+        promptLength: userPrompt.length
+      });
+      const diffProc = Bun.spawnSync([
+        "git",
+        "show",
+        commitId,
+        "--format=",
+        "--no-color"
+      ], { cwd, stdout: "pipe", stderr: "pipe" });
+      if (diffProc.exitCode !== 0)
+        return null;
+      const diff = diffProc.stdout.toString().trim();
+      if (!diff)
+        return null;
+      const truncatedDiff = diff.length > MAX_DIFF_CHARS ? diff.slice(0, MAX_DIFF_CHARS) + `
+... (truncated)` : diff;
+      const sessionRes = await client.session.create({
+        body: { title: "commit-msg-gen" }
+      });
+      if (!sessionRes.data)
+        return null;
+      const tempSessionId = sessionRes.data.id;
+      internalSessionIds.add(tempSessionId);
+      try {
+        const promptText = [
+          "Generate a one-line conventional commit message for this diff.",
+          "Format: type: description (max 72 chars total).",
+          "Types: feat, fix, refactor, test, docs, style, perf, chore.",
+          `User intent: "${userPrompt.split(`
+`)[0]?.trim().slice(0, 200) ?? ""}"`,
+          "",
+          "Diff:",
+          truncatedDiff,
+          "",
+          "Reply with ONLY the commit message, nothing else."
+        ].join(`
+`);
+        const timeoutPromise = new Promise((resolve3) => setTimeout(() => resolve3(null), LLM_TIMEOUT_MS));
+        const llmPromise = client.session.prompt({
+          path: { id: tempSessionId },
+          body: {
+            model: {
+              providerID: config.commit_message_provider,
+              modelID: config.commit_message_model
+            },
+            system: "You are a commit message generator. Output ONLY a single-line conventional commit message. No explanation, no markdown, no quotes, no code fences.",
+            tools: {},
+            parts: [
+              { type: "text", text: promptText }
+            ]
+          }
+        });
+        const response = await Promise.race([
+          llmPromise,
+          timeoutPromise
+        ]);
+        if (!response || !("data" in response) || !response.data) {
+          log.warn("llm-timeout-or-empty", {
+            commitId
+          });
+          return null;
+        }
+        const textPart = response.data.parts.find((p) => p.type === "text");
+        if (!textPart?.text)
+          return null;
+        const message = textPart.text.trim().replace(/^["'`]+|["'`]+$/g, "").split(`
+`)[0]?.trim();
+        if (!message)
+          return null;
+        const validPrefix = /^(feat|fix|refactor|test|docs|style|perf|chore|ci|build)(\(.+?\))?:\s/;
+        if (!validPrefix.test(message)) {
+          log.warn("llm-invalid-format", {
+            commitId,
+            message
+          });
+          return null;
+        }
+        if (message.length > 72)
+          return message.slice(0, 69) + "...";
+        log.info("llm-success", {
+          commitId,
+          message
+        });
+        return message;
+      } finally {
+        internalSessionIds.delete(tempSessionId);
+        client.session.delete({ path: { id: tempSessionId } }).catch(() => {});
+      }
+    } catch {
+      return null;
+    }
+  }
+  async function postStopProcessing(sessionID, conversationId, stopFailed = false) {
+    if (!sessionID)
+      return;
+    const rootSessionID = resolveSessionRoot(sessionID);
+    log.info("post-stop-start", {
+      sessionID,
+      rootSessionID
+    });
+    if (stopFailed) {
+      log.warn("post-stop-degraded", {
+        sessionID,
+        rootSessionID,
+        reason: "stop command failed, attempting recovery"
+      });
+    }
+    reapStaleLocks();
+    const editedFiles = editedFilesPerConversation.get(conversationId);
+    let sweepRubCount = 0;
+    if (editedFiles && editedFiles.size > 0) {
+      for (const filePath of editedFiles) {
+        try {
+          const branchInfo = cli.findFileBranch(filePath);
+          if (branchInfo.unassignedCliId && branchInfo.branchCliId) {
+            if (!cli.hasMultiBranchHunks(filePath)) {
+              const rubOk = cli.butRub(branchInfo.unassignedCliId, branchInfo.branchCliId);
+              if (rubOk) {
+                sweepRubCount++;
+                log.info("post-stop-sweep-rub", {
+                  file: filePath,
+                  source: branchInfo.unassignedCliId,
+                  dest: branchInfo.branchCliId
+                });
+              }
+            }
+          }
+        } catch {}
+      }
+      if (sweepRubCount > 0) {
+        log.info("post-stop-sweep-summary", {
+          conversationId,
+          filesChecked: editedFiles.size,
+          rubbed: sweepRubCount
+        });
+      }
+    }
+    const prompt = await fetchUserPrompt(rootSessionID);
+    if (!prompt)
+      return;
+    const status = cli.getFullStatus();
+    if (!status?.stacks)
+      return;
+    const ownershipSnapshot = [];
+    for (const stack of status.stacks) {
+      for (const branch of stack.branches ?? []) {
+        if (branch.commits.length > 0 || (stack.assignedChanges?.length ?? 0) > 0) {
+          ownershipSnapshot.push({
+            branchName: branch.name,
+            branchCliId: branch.cliId,
+            commitCount: branch.commits.length
+          });
+        }
+      }
+    }
+    log.info("branch-ownership-snapshot", {
+      sessionID,
+      rootSessionID,
+      branches: ownershipSnapshot
+    });
+    let rewordCount = 0;
+    let renameCount = 0;
+    let cleanupCount = 0;
+    let failCount = 0;
+    let latestBranchName = null;
+    for (const stack of status.stacks) {
+      for (const branch of stack.branches ?? []) {
+        if (branch.branchStatus !== "completelyUnpushed")
+          continue;
+        if (branch.commits.length === 0)
+          continue;
+        if (rewordedBranches.has(branch.cliId))
+          continue;
+        const commit = branch.commits[0];
+        if (!commit)
+          continue;
+        try {
+          const VALID_CONVENTIONAL = /^(feat|fix|refactor|test|docs|style|perf|chore|ci|build)(\(.+?\))?:\s/;
+          const DEFAULT_PLACEHOLDERS = [
+            "session changes",
+            "opencode session changes",
+            "cursor session changes"
+          ];
+          const existingMsg = commit.message?.trim() ?? "";
+          const isAlreadyReworded = VALID_CONVENTIONAL.test(existingMsg) && !DEFAULT_PLACEHOLDERS.some((p) => existingMsg.toLowerCase().includes(p));
+          if (isAlreadyReworded) {
+            log.info("reword-skipped-existing", {
+              branch: branch.name,
+              commit: commit.cliId,
+              existingMessage: existingMsg
+            });
+            rewordedBranches.add(branch.cliId);
+            rewordCount++;
+          } else {
+            const llmMessage = await generateLLMCommitMessage(commit.commitId, prompt);
+            const commitMsg = llmMessage ?? toCommitMessage(prompt);
+            let rewordResult = cli.butReword(commit.cliId, commitMsg);
+            if (!rewordResult.ok) {
+              const isLocked = rewordResult.stderr.includes("locked") || rewordResult.stderr.includes("SQLITE_BUSY");
+              if (isLocked) {
+                await Bun.sleep(1000);
+                rewordResult = cli.butReword(commit.cliId, commitMsg);
+              }
+            }
+            if (!rewordResult.ok) {
+              const reason = classifyRewordFailure(rewordResult.stderr);
+              log.warn("reword-failed", {
+                branch: branch.name,
+                commit: commit.cliId,
+                message: commitMsg,
+                reason,
+                stderr: rewordResult.stderr.slice(0, 300)
+              });
+              failCount++;
+              continue;
+            }
+            rewordedBranches.add(branch.cliId);
+            savePluginState(conversationsWithEdits, rewordedBranches, branchOwnership).catch(() => {});
+            addNotification(sessionID, `Commit on branch \`${branch.name}\` reworded to: "${commitMsg}"`);
+            log.info("reword", {
+              branch: branch.name,
+              commit: commit.cliId,
+              message: commitMsg,
+              source: llmMessage ? "llm" : "deterministic",
+              multi: branch.commits.length > 1
+            });
+            rewordCount++;
+          }
+          if (defaultBranchPattern.test(branch.name)) {
+            latestBranchName = toBranchSlug(prompt, config.branch_slug_max_length);
+            const renameResult = cli.butReword(branch.cliId, latestBranchName);
+            if (renameResult.ok) {
+              log.info("branch-rename", {
+                status: "ok",
+                from: branch.name,
+                to: latestBranchName
+              });
+              addNotification(sessionID, `Branch renamed from \`${branch.name}\` to \`${latestBranchName}\``);
+              renameCount++;
+            } else {
+              log.warn("branch-rename", {
+                status: "failed",
+                from: branch.name,
+                to: latestBranchName,
+                reason: classifyRewordFailure(renameResult.stderr),
+                stderr: renameResult.stderr.slice(0, 300)
+              });
+              latestBranchName = branch.name;
+              failCount++;
+            }
+          } else {
+            log.info("branch-rename", {
+              status: "skipped",
+              branch: branch.name,
+              reason: "user-named"
+            });
+            latestBranchName = branch.name;
+          }
+        } catch (err) {
+          log.error("reword-error", {
+            branch: branch.name,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    }
+    if (!latestBranchName) {
+      const existing = status.stacks.flatMap((s) => s.branches ?? []).filter((b) => b.commits.length > 0 && !defaultBranchPattern.test(b.name));
+      if (existing.length > 0) {
+        latestBranchName = existing[existing.length - 1].name;
+      }
+    }
+    if (latestBranchName) {
+      client.session.update({
+        path: { id: rootSessionID },
+        body: { title: latestBranchName }
+      }).catch(() => {});
+      addNotification(sessionID, `Session title updated to \`${latestBranchName}\``);
+    }
+    for (const stack of status.stacks) {
+      for (const branch of stack.branches ?? []) {
+        if (branch.commits.length === 0 && (stack.assignedChanges?.length ?? 0) === 0 && defaultBranchPattern.test(branch.name)) {
+          const ok = await cli.butUnapplyWithRetry(branch.cliId, branch.name);
+          if (ok) {
+            addNotification(sessionID, `Empty branch \`${branch.name}\` cleaned up`);
+            cleanupCount++;
+          }
+        }
+      }
+    }
+    log.info("post-stop-summary", {
+      sessionID,
+      rootSessionID,
+      reworded: rewordCount,
+      renamed: renameCount,
+      cleanedUp: cleanupCount,
+      failed: failCount,
+      stopFailed
+    });
+  }
+  return {
+    fetchUserPrompt,
+    generateLLMCommitMessage,
+    postStopProcessing
+  };
+}
+
+// src/plugin.ts
+function createGitButlerPlugin(config = { ...DEFAULT_CONFIG }) {
+  return async ({ client, directory, worktree }) => {
+    const cwd = worktree ?? directory;
+    const log = createLogger(config.log_enabled, cwd);
+    const cli = createCli(cwd, log);
+    const state = createStateManager(cwd, log);
+    const diskSessionMap = await state.loadSessionMap();
+    for (const [k, v] of diskSessionMap) {
+      state.parentSessionByTaskSession.set(k, v);
+    }
+    const branchOwnership = new Map;
+    const persistedState = await state.loadPluginState();
+    const conversationsWithEdits = new Set(persistedState.conversationsWithEdits);
+    const rewordedBranches = new Set(persistedState.rewordedBranches);
+    for (const [convId, ownership] of Object.entries(persistedState.branchOwnership ?? {})) {
+      branchOwnership.set(convId, ownership);
+    }
+    log.info("state-loaded", {
+      conversations: conversationsWithEdits.size,
+      reworded: rewordedBranches.size,
+      logEnabled: config.log_enabled,
+      autoUpdate: config.auto_update,
+      commitModel: config.commit_message_model
+    });
+    log.info("plugin-init", {
+      workspaceMode: cli.isWorkspaceMode(),
+      sessionMapSize: state.parentSessionByTaskSession.size
+    });
+    const internalSessionIds = new Set;
+    const activeStopProcessing = new Set;
+    let mainSessionID;
+    const notify = createNotificationManager(log, state.resolveSessionRoot, config.notification_max_age_ms);
+    let DEFAULT_BRANCH_PATTERN;
+    try {
+      DEFAULT_BRANCH_PATTERN = new RegExp(config.default_branch_pattern);
+    } catch {
+      DEFAULT_BRANCH_PATTERN = new RegExp(DEFAULT_CONFIG.default_branch_pattern);
+    }
+    const fileLocks = new Map;
+    const LOCK_TIMEOUT_MS = 60000;
+    const LOCK_POLL_MS = 1000;
+    const STALE_LOCK_MS = 5 * 60000;
+    function reapStaleLocks() {
+      const now = Date.now();
+      const staleCutoff = config.stale_lock_ms ?? STALE_LOCK_MS;
+      for (const [filePath, lock] of fileLocks.entries()) {
+        if (now - lock.timestamp > staleCutoff) {
+          fileLocks.delete(filePath);
+          log.info("lock-reaped", {
+            file: filePath,
+            owner: lock.sessionID,
+            ageMs: now - lock.timestamp,
+            operation: lock.operation
+          });
+        }
+      }
+    }
+    const editedFilesPerConversation = new Map;
+    const reword = createRewordManager({
+      cwd,
+      log,
+      cli,
+      config,
+      defaultBranchPattern: DEFAULT_BRANCH_PATTERN,
+      addNotification: notify.addNotification,
+      resolveSessionRoot: state.resolveSessionRoot,
+      conversationsWithEdits,
+      rewordedBranches,
+      branchOwnership,
+      editedFilesPerConversation,
+      savePluginState: state.savePluginState,
+      internalSessionIds,
+      reapStaleLocks,
+      client
+    });
+    const assignmentCache = new Map;
+    const ASSIGNMENT_CACHE_TTL_MS = 30000;
+    let cachedStatus = null;
+    const STATUS_CACHE_TTL_MS = 1e4;
+    function getCachedStatus() {
+      if (cachedStatus && Date.now() - cachedStatus.timestamp < STATUS_CACHE_TTL_MS) {
+        return cachedStatus.data;
+      }
+      const fresh = cli.getFullStatus();
+      cachedStatus = { data: fresh, timestamp: Date.now() };
+      return fresh;
+    }
+    async function toUUID(input) {
+      const data = new TextEncoder().encode(input);
+      const hash = await crypto.subtle.digest("SHA-256", data);
+      const hex = [...new Uint8Array(hash)].map((b) => b.toString(16).padStart(2, "0")).join("");
+      return [
+        hex.slice(0, 8),
+        hex.slice(8, 12),
+        `4${hex.slice(12, 15)}`,
+        `8${hex.slice(15, 18)}`,
+        hex.slice(18, 30)
+      ].join("-");
+    }
+    function extractFilePathFromArgs(args) {
+      const raw = args.filePath ?? args.file_path ?? args.path;
+      return raw ? cli.toRelativePath(raw) : undefined;
+    }
+    return {
+      "tool.execute.before": async (input, output) => {
+        if (internalSessionIds.has(input.sessionID ?? ""))
+          return;
+        if (input.tool !== "edit" && input.tool !== "write")
+          return;
+        if (!output.args)
+          return;
+        const filePath = extractFilePathFromArgs(output.args);
+        if (!filePath)
+          return;
+        const sessionID = input.sessionID ?? "unknown";
+        const existing = fileLocks.get(filePath);
+        if (existing) {
+          const isStale = Date.now() - existing.timestamp > STALE_LOCK_MS;
+          if (isStale) {
+            log.warn("lock-stale", {
+              file: filePath,
+              owner: existing.sessionID,
+              ageMs: Date.now() - existing.timestamp,
+              ownerOperation: existing.operation
+            });
+          } else if (existing.sessionID !== sessionID) {
+            log.info("lock-contention", {
+              file: filePath,
+              owner: existing.sessionID,
+              ownerOperation: existing.operation,
+              ownerAgeMs: Date.now() - existing.timestamp,
+              waiter: sessionID,
+              waiterOperation: input.tool
+            });
+            const deadline = Date.now() + LOCK_TIMEOUT_MS;
+            while (Date.now() < deadline) {
+              await Bun.sleep(LOCK_POLL_MS);
+              const current = fileLocks.get(filePath);
+              if (!current || current.sessionID === sessionID || Date.now() - current.timestamp > STALE_LOCK_MS)
+                break;
+            }
+            const stillLocked = fileLocks.get(filePath);
+            if (stillLocked && stillLocked.sessionID !== sessionID && Date.now() - stillLocked.timestamp <= STALE_LOCK_MS) {
+              log.error("lock-timeout", {
+                file: filePath,
+                owner: stillLocked.sessionID,
+                ownerOperation: stillLocked.operation,
+                ownerAgeMs: Date.now() - stillLocked.timestamp,
+                waiter: sessionID,
+                waiterOperation: input.tool
+              });
+            }
+          }
+        }
+        const previousLock = fileLocks.get(filePath);
+        fileLocks.set(filePath, {
+          sessionID,
+          timestamp: Date.now(),
+          operation: input.tool ?? "unknown"
+        });
+        log.info("lock-acquired", {
+          file: filePath,
+          session: sessionID,
+          operation: input.tool,
+          ...previousLock ? { previousAgeMs: Date.now() - previousLock.timestamp } : {}
+        });
+      },
+      "tool.execute.after": async (input, output) => {
+        if (internalSessionIds.has(input.sessionID ?? ""))
+          return;
+        await state.trackSubagentMapping(input, output);
+        if (input.tool !== "edit" && input.tool !== "write")
+          return;
+        if (!cli.isWorkspaceMode())
+          return;
+        const filePath = cli.extractFilePath(output);
+        if (!filePath) {
+          const sessionID = input.sessionID ?? "unknown";
+          let releasedCount = 0;
+          for (const [
+            lockedPath,
+            lock
+          ] of fileLocks.entries()) {
+            if (lock.sessionID === sessionID) {
+              fileLocks.delete(lockedPath);
+              releasedCount++;
+            }
+          }
+          log.info("after-edit-no-filepath", {
+            sessionID,
+            tool: input.tool,
+            locksReleased: releasedCount
+          });
+          return;
+        }
+        const relativePath = cli.toRelativePath(filePath);
+        try {
+          const cached = assignmentCache.get(relativePath);
+          const cacheHit = cached && Date.now() - cached.timestamp < ASSIGNMENT_CACHE_TTL_MS;
+          if (!cacheHit) {
+            const statusSnapshot = cli.getFullStatus();
+            const branchInfo = cli.findFileBranch(relativePath, statusSnapshot);
+            if (branchInfo.inBranch) {
+              if (branchInfo.unassignedCliId && branchInfo.branchCliId) {
+                if (cli.hasMultiBranchHunks(relativePath, statusSnapshot)) {
+                  log.warn("rub-skip-multi-branch", {
+                    file: relativePath
+                  });
+                } else {
+                  log.info("rub-check", {
+                    file: relativePath,
+                    multiBranch: false,
+                    source: branchInfo.unassignedCliId,
+                    dest: branchInfo.branchCliId
+                  });
+                  const rubOk = cli.butRub(branchInfo.unassignedCliId, branchInfo.branchCliId);
+                  if (rubOk) {
+                    log.info("rub-ok", {
+                      source: branchInfo.unassignedCliId,
+                      dest: branchInfo.branchCliId,
+                      file: relativePath
+                    });
+                  } else {
+                    log.error("rub-failed", {
+                      source: branchInfo.unassignedCliId,
+                      dest: branchInfo.branchCliId,
+                      file: relativePath
+                    });
+                  }
+                }
+              } else {
+                log.info("after-edit-already-assigned", {
+                  file: relativePath,
+                  sessionID: input.sessionID,
+                  branch: branchInfo.branchName
+                });
+              }
+              return;
+            }
+          } else {
+            log.info("assignment-cache-hit", {
+              file: relativePath,
+              branchCliId: cached.branchCliId,
+              ageMs: Date.now() - cached.timestamp
+            });
+          }
+          const branchSeed = config.branch_target ?? state.resolveSessionRoot(input.sessionID);
+          const conversationId = cacheHit ? cached.conversationId : await toUUID(branchSeed);
+          log.info("after-edit", {
+            file: relativePath,
+            sessionID: input.sessionID,
+            conversationId
+          });
+          try {
+            await cli.butCursor("after-edit", {
+              conversation_id: conversationId,
+              generation_id: crypto.randomUUID(),
+              file_path: relativePath,
+              edits: cli.extractEdits(output),
+              hook_event_name: "afterFileEdit",
+              workspace_roots: [cwd]
+            });
+            assignmentCache.set(relativePath, {
+              branchCliId: conversationId,
+              conversationId,
+              timestamp: Date.now()
+            });
+          } catch (err) {
+            log.error("cursor-after-edit-error", {
+              file: relativePath,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+          conversationsWithEdits.add(conversationId);
+          if (!editedFilesPerConversation.has(conversationId)) {
+            editedFilesPerConversation.set(conversationId, new Set);
+          }
+          editedFilesPerConversation.get(conversationId).add(relativePath);
+          const rootSessionID = state.resolveSessionRoot(input.sessionID);
+          const existingOwner = branchOwnership.get(conversationId);
+          if (existingOwner && existingOwner.rootSessionID !== rootSessionID) {
+            log.error("branch-collision", {
+              conversationId,
+              existingOwner: existingOwner.rootSessionID,
+              newOwner: rootSessionID,
+              existingBranch: existingOwner.branchName
+            });
+          } else if (!existingOwner) {
+            branchOwnership.set(conversationId, {
+              rootSessionID,
+              branchName: `conversation-${conversationId.slice(0, 8)}`,
+              firstSeen: Date.now()
+            });
+          }
+          state.savePluginState(conversationsWithEdits, rewordedBranches, branchOwnership).catch(() => {});
+        } finally {
+          const releasedLock = fileLocks.get(relativePath);
+          fileLocks.delete(relativePath);
+          log.info("lock-released", {
+            file: relativePath,
+            session: input.sessionID,
+            ...releasedLock ? { heldMs: Date.now() - releasedLock.timestamp } : {}
+          });
+        }
+      },
+      event: async ({ event }) => {
+        if (!event?.type)
+          return;
+        const eventProps = event.properties;
+        if (internalSessionIds.has(eventProps?.sessionID ?? ""))
+          return;
+        await state.trackSessionCreatedMapping(event);
+        if (event.type === "session.created") {
+          const crProps = event.properties;
+          const sessId = typeof crProps?.id === "string" ? crProps.id : undefined;
+          const parentId = typeof crProps?.parentSessionID === "string" ? crProps.parentSessionID : typeof crProps?.parent_session_id === "string" ? crProps.parent_session_id : undefined;
+          if (sessId && !parentId) {
+            mainSessionID = sessId;
+          }
+        }
+        const props = event.properties;
+        const isIdle = event.type === "session.idle" || event.type === "session.status" && props?.status?.type === "idle";
+        if (!isIdle)
+          return;
+        if (!cli.isWorkspaceMode())
+          return;
+        const branchSeed = config.branch_target ?? state.resolveSessionRoot(props?.sessionID);
+        const conversationId = await toUUID(branchSeed);
+        if (!conversationsWithEdits.has(conversationId))
+          return;
+        if (activeStopProcessing.has(conversationId))
+          return;
+        activeStopProcessing.add(conversationId);
+        try {
+          log.info("session-stop", {
+            sessionID: props?.sessionID,
+            conversationId
+          });
+          let stopFailed = false;
+          try {
+            await cli.butCursor("stop", {
+              conversation_id: conversationId,
+              generation_id: crypto.randomUUID(),
+              status: "completed",
+              hook_event_name: "stop",
+              workspace_roots: [cwd]
+            });
+          } catch (err) {
+            stopFailed = true;
+            log.error("cursor-stop-error", {
+              conversationId,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+          await reword.postStopProcessing(props?.sessionID, conversationId, stopFailed);
+          assignmentCache.clear();
+          cachedStatus = null;
+        } finally {
+          activeStopProcessing.delete(conversationId);
+        }
+      },
+      "experimental.chat.messages.transform": async (_input, output) => {
+        const { messages } = output;
+        if (messages.length === 0)
+          return;
+        let lastUserMsgIdx = -1;
+        for (let i = messages.length - 1;i >= 0; i--) {
+          if (messages[i].info.role === "user") {
+            lastUserMsgIdx = i;
+            break;
+          }
+        }
+        if (lastUserMsgIdx === -1)
+          return;
+        const lastUserMessage = messages[lastUserMsgIdx];
+        const messageSessionID = lastUserMessage.info.sessionID;
+        const sessionID = messageSessionID ?? mainSessionID;
+        if (!sessionID)
+          return;
+        const notification = notify.consumeNotifications(sessionID);
+        if (!notification)
+          return;
+        const textPartIndex = lastUserMessage.parts.findIndex((p) => p.type === "text" && p.text);
+        if (textPartIndex === -1)
+          return;
+        const syntheticPart = {
+          id: `gitbutler_ctx_${Date.now()}`,
+          messageID: lastUserMessage.info.id,
+          sessionID,
+          type: "text",
+          text: notification,
+          synthetic: true
+        };
+        lastUserMessage.parts.splice(textPartIndex, 0, syntheticPart);
+        log.info("context-injected", {
+          sessionID,
+          contentLength: notification.length
+        });
+      },
+      "experimental.session.compacting": async (input, output) => {
+        try {
+          const rootSessionID = state.resolveSessionRoot(input.sessionID);
+          const conversationId = await toUUID(rootSessionID);
+          const contextParts = [];
+          const status = getCachedStatus();
+          if (status?.stacks) {
+            const stacks = status.stacks;
+            const activeBranches = stacks.flatMap((s) => s.branches ?? []).filter((b) => b.commits.length > 0 || (stacks.find((s) => (s.branches ?? []).includes(b))?.assignedChanges?.length ?? 0) > 0);
+            if (activeBranches.length > 0) {
+              const branchList = activeBranches.map((b) => `- \`${b.name}\` (${b.commits.length} commits)`).join(`
+`);
+              contextParts.push(`Active GitButler branches:
+${branchList}`);
+            }
+          }
+          if (rewordedBranches.size > 0) {
+            contextParts.push(`Reworded branches (commit messages updated): ${rewordedBranches.size} branches`);
+          }
+          if (conversationsWithEdits.has(conversationId)) {
+            contextParts.push(`This session has active edits tracked in GitButler (conversation: ${conversationId.slice(0, 8)})`);
+          }
+          const ownership = branchOwnership.get(conversationId);
+          if (ownership) {
+            contextParts.push(`Session branch ownership: root=${ownership.rootSessionID.slice(0, 8)}, branch=${ownership.branchName}`);
+          }
+          if (contextParts.length > 0) {
+            output.context.push(`<gitbutler-state>
+` + contextParts.join(`
+
+`) + `
+</gitbutler-state>`);
+            log.info("compacting-context-injected", {
+              sessionID: input.sessionID,
+              contextItems: contextParts.length
+            });
+          }
+        } catch {}
+      },
+      "experimental.chat.system.transform": async (_input, output) => {
+        if (!cli.isWorkspaceMode())
+          return;
+        try {
+          const status = getCachedStatus();
+          if (!status?.stacks)
+            return;
+          const activeBranches = status.stacks.flatMap((s) => s.branches ?? []).filter((b) => b.commits.length > 0);
+          const unassignedCount = status.unassignedChanges?.length ?? 0;
+          if (activeBranches.length === 0 && unassignedCount === 0)
+            return;
+          const branchNames = activeBranches.map((b) => b.name).join(", ");
+          output.system.push(`[GitButler] Workspace mode active. ` + `${activeBranches.length} branch(es): ${branchNames}. ` + `${unassignedCount} unassigned change(s).`);
+        } catch {}
+      }
+    };
+  };
+}
+
+// src/auto-update.ts
+var NPM_DIST_TAGS_URL = "https://registry.npmjs.org/-/package/opencode-gitbutler/dist-tags";
+var FETCH_TIMEOUT_MS = 5000;
+function parseVersion(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
+  if (!match)
+    return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ?? ""
+  };
+}
+function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb)
+    return 0;
+  for (const field of ["major", "minor", "patch"]) {
+    if (pa[field] > pb[field])
+      return 1;
+    if (pa[field] < pb[field])
+      return -1;
+  }
+  if (!pa.prerelease && pb.prerelease)
+    return 1;
+  if (pa.prerelease && !pb.prerelease)
+    return -1;
+  if (pa.prerelease < pb.prerelease)
+    return -1;
+  if (pa.prerelease > pb.prerelease)
+    return 1;
+  return 0;
+}
+async function checkForUpdate(currentVersion) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(NPM_DIST_TAGS_URL, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    const latest = data.latest;
+    if (!latest || typeof latest !== "string")
+      return null;
+    return {
+      current: currentVersion,
+      latest,
+      updateAvailable: compareVersions(latest, currentVersion) > 0
+    };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function formatUpdateMessage(info) {
+  return `opencode-gitbutler update available: ${info.current} \u2192 ${info.latest}. ` + `Run \`bun add opencode-gitbutler@latest\` to update.`;
+}
+function createAutoUpdateHook(config) {
+  if (config.auto_update === false) {
+    return { onSessionCreated: async () => null };
+  }
+  let checked = false;
+  let pendingMessage = null;
+  let checkPromise = null;
+  checkPromise = checkForUpdate(config.currentVersion).then((info) => {
+    if (info?.updateAvailable) {
+      pendingMessage = formatUpdateMessage(info);
+    }
+  }).catch(() => {}).finally(() => {
+    checkPromise = null;
+  });
+  return {
+    onSessionCreated: async () => {
+      if (checked)
+        return null;
+      checked = true;
+      if (checkPromise) {
+        await checkPromise;
+      }
+      const msg = pendingMessage;
+      pendingMessage = null;
+      return msg;
+    }
+  };
+}
+
+// src/index.ts
+var DUPLICATE_GUARD_KEY = "__opencode_gitbutler_loaded__";
+var pkg = await Bun.file(new URL("../package.json", import.meta.url)).json();
+var PACKAGE_VERSION = pkg.version;
+var COMMAND_FILES = ["b-branch", "b-branch-commit", "b-branch-pr", "b-branch-gc"];
+function parseFrontmatter(content) {
+  const lines = content.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") {
+    return { fields: {}, template: content };
+  }
+  let frontmatterEnd = -1;
+  for (let i = 1;i < lines.length; i += 1) {
+    if (lines[i]?.trim() === "---") {
+      frontmatterEnd = i;
+      break;
+    }
+  }
+  if (frontmatterEnd === -1) {
+    return { fields: {}, template: content };
+  }
+  const fields = {};
+  for (const line of lines.slice(1, frontmatterEnd)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const separatorIndex = trimmed.indexOf(":");
+    if (separatorIndex === -1)
+      continue;
+    const key = trimmed.slice(0, separatorIndex).trim();
+    const rawValue = trimmed.slice(separatorIndex + 1).trim();
+    if (!key)
+      continue;
+    if (!key)
+      continue;
+    const isQuoted = rawValue.startsWith('"') && rawValue.endsWith('"') || rawValue.startsWith("'") && rawValue.endsWith("'");
+    let parsedValue;
+    if (isQuoted) {
+      parsedValue = rawValue.slice(1, -1);
+    } else if (rawValue === "true" || rawValue === "false") {
+      parsedValue = rawValue === "true";
+    } else if (/^-?\d+(?:\.\d+)?$/.test(rawValue)) {
+      parsedValue = Number(rawValue);
+    } else {
+      parsedValue = rawValue;
+    }
+    fields[key] = parsedValue;
+  }
+  return {
+    fields,
+    template: lines.slice(frontmatterEnd + 1).join(`
+`)
+  };
+}
+async function loadCommands() {
+  const commands = {};
+  for (const commandName of COMMAND_FILES) {
+    try {
+      const commandPath = new URL(`../command/${commandName}.md`, import.meta.url);
+      const file = Bun.file(commandPath);
+      if (!await file.exists()) {
+        continue;
+      }
+      const source = await file.text();
+      const { fields, template } = parseFrontmatter(source);
+      const command = {
+        template
+      };
+      if (typeof fields.description === "string") {
+        command.description = fields.description;
+      }
+      if (typeof fields.agent === "string") {
+        command.agent = fields.agent;
+      }
+      if (typeof fields.model === "string") {
+        command.model = fields.model;
+      }
+      if (typeof fields.subtask === "boolean") {
+        command.subtask = fields.subtask;
+      }
+      commands[commandName] = command;
+    } catch {
+      continue;
+    }
+  }
+  return commands;
+}
+var GitButlerPlugin = async (input) => {
+  const g = globalThis;
+  if (g[DUPLICATE_GUARD_KEY]) {
+    console.warn("[opencode-gitbutler] Plugin already loaded \u2014 skipping duplicate registration.");
+    return {};
+  }
+  g[DUPLICATE_GUARD_KEY] = true;
+  const cwd = input.worktree ?? input.directory;
+  const config = await loadConfig(cwd);
+  const hooks = await createGitButlerPlugin(config)(input);
+  const autoUpdate = createAutoUpdateHook({
+    currentVersion: PACKAGE_VERSION,
+    auto_update: config.auto_update
+  });
+  const skillDir = new URL("../skill", import.meta.url).pathname;
+  const commandDefinitions = await loadCommands();
+  const originalEvent = hooks.event;
+  hooks.event = async (payload) => {
+    if (originalEvent) {
+      await originalEvent(payload);
+    }
+    if (payload.event?.type === "session.created") {
+      const props = payload.event.properties;
+      const hasParent = typeof props?.parentSessionID === "string" || typeof props?.parent_session_id === "string";
+      if (!hasParent) {
+        const msg = await autoUpdate.onSessionCreated();
+        if (msg) {
+          console.warn(`[opencode-gitbutler] ${msg}`);
+        }
+      }
+    }
+  };
+  const originalConfig = hooks.config;
+  hooks.config = async (config2) => {
+    if (originalConfig) {
+      await originalConfig(config2);
+    }
+    const extendedConfig = config2;
+    if (!extendedConfig.skills)
+      extendedConfig.skills = {};
+    if (!extendedConfig.skills.paths)
+      extendedConfig.skills.paths = [];
+    if (!extendedConfig.skills.paths.includes(skillDir)) {
+      extendedConfig.skills.paths.push(skillDir);
+    }
+    if (!extendedConfig.command) {
+      extendedConfig.command = {};
+    }
+    for (const [name, definition] of Object.entries(commandDefinitions)) {
+      extendedConfig.command[name] = definition;
+    }
+  };
+  return hooks;
+};
+var src_default = GitButlerPlugin;
+export {
+  src_default as default,
+  GitButlerPlugin
+};