@link-assistant/hive-mind 2.11.13 → 2.12.1

package/src/solve.session.lib.mjs

@@ -62,6 +62,48 @@ function getSessionCommentContent(sessionType, timestamp) {
   }
 }
 
+/**
+ * Post the tracked comment that marks a work-session start.
+ *
+ * This is separate from startWorkSession because an in-process continuation
+ * after a usage-limit wait is already inside a work session: the PR is already
+ * draft, but reviewers still need an explicit boundary for the resumed tool
+ * execution.
+ *
+ * @param {Object} options
+ * @param {string} options.owner
+ * @param {string} options.repo
+ * @param {number} options.prNumber
+ * @param {Function} options.$
+ * @param {Function} options.log
+ * @param {Function} options.formatAligned
+ * @param {string} options.sessionType
+ * @param {Date} [options.timestamp]
+ */
+export async function postWorkSessionStartComment({ owner, repo, prNumber, $, log, formatAligned, sessionType, timestamp = new Date() }) {
+  try {
+    const { emoji, header, description } = getSessionCommentContent(sessionType, timestamp);
+    const startComment = `${emoji} **${header}**\n\n${description}`;
+    const { ok, commentId, stderr } = await postTrackedComment({ $, owner, repo, targetNumber: prNumber, body: startComment });
+    if (ok) {
+      await log(formatAligned('💬', 'Posted:', `${header} comment${commentId ? ` (id=${commentId})` : ''}`, 2));
+    } else {
+      await log(`Warning: Could not post work start comment: ${stderr || 'unknown error'}`, { level: 'warning' });
+    }
+  } catch (error) {
+    const sentryLib = await import('./sentry.lib.mjs');
+    const { reportError } = sentryLib;
+    reportError(error, {
+      context: 'post_start_comment',
+      owner,
+      repo,
+      prNumber,
+      operation: 'create_pr_comment',
+    });
+    await log('Warning: Could not post work start comment', { level: 'warning' });
+  }
+}
+
 /**
  * Start a work session and post appropriate comment
  * @param {Object} options - Session options
@@ -101,25 +143,16 @@ export async function startWorkSession({ isContinueMode, prNumber, argv, log, fo
     // Post a comment marking the start of work session with appropriate header based on session type.
     // Issue #1625: Use postTrackedComment so the comment ID is registered in-memory and can be
     // excluded from the "did the AI post anything?" check in checkForAiCreatedComments().
-    try {
-      const { emoji, header, description } = getSessionCommentContent(sessionType, workStartTime);
-      const startComment = `${emoji} **${header}**\n\n${description}`;
-      const { ok, commentId, stderr } = await postTrackedComment({ $, owner: global.owner, repo: global.repo, targetNumber: prNumber, body: startComment });
-      if (ok) {
-        await log(formatAligned('💬', 'Posted:', `${header} comment${commentId ? ` (id=${commentId})` : ''}`, 2));
-      } else {
-        await log(`Warning: Could not post work start comment: ${stderr || 'unknown error'}`, { level: 'warning' });
-      }
-    } catch (error) {
-      const sentryLib = await import('./sentry.lib.mjs');
-      const { reportError } = sentryLib;
-      reportError(error, {
-        context: 'post_start_comment',
-        prNumber,
-        operation: 'create_pr_comment',
-      });
-      await log('Warning: Could not post work start comment', { level: 'warning' });
-    }
+    await postWorkSessionStartComment({
+      owner: global.owner,
+      repo: global.repo,
+      prNumber,
+      $,
+      log,
+      formatAligned,
+      sessionType,
+      timestamp: workStartTime,
+    });
   }
 
   return workStartTime;

package/src/solve.tool-uncommitted.lib.mjs

@@ -0,0 +1,22 @@
+const TOOL_MODULES = {
+  agent: './agent.lib.mjs',
+  codex: './codex.lib.mjs',
+  gemini: './gemini.lib.mjs',
+  opencode: './opencode.lib.mjs',
+  qwen: './qwen.lib.mjs',
+};
+
+export async function resolveUncommittedChangesTool({ argv, claudeLib, importModule = specifier => import(specifier) }) {
+  if (argv.useAgentCommander) {
+    const agentCommanderLib = await importModule('./agent-commander.lib.mjs');
+    return { agentCommanderLib, checkForUncommittedChanges: agentCommanderLib.checkForUncommittedChanges };
+  }
+
+  const toolModule = TOOL_MODULES[argv.tool];
+  if (toolModule) {
+    const module = await importModule(toolModule);
+    return { agentCommanderLib: null, checkForUncommittedChanges: module.checkForUncommittedChanges };
+  }
+
+  return { agentCommanderLib: null, checkForUncommittedChanges: claudeLib.checkForUncommittedChanges };
+}

package/src/state-lock.lib.mjs

@@ -0,0 +1,82 @@
+/**
+ * Cross-process exclusive locks over the durable bot state directory.
+ *
+ * Issue #2146 introduced two background maintainers — the Formal AI sidecar
+ * lifecycle and the agentic-CLI refresh — that must never interleave with the
+ * work they maintain. Both need the same primitive, so it lives here once.
+ *
+ * `mkdir` is the lock: it is atomic on every filesystem the bot runs on, unlike
+ * "check then create" with a regular file. A lock older than `staleMs` is
+ * broken so a killed process cannot deadlock the bot forever.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2146
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { resolveBotStateDir } from './session-store.lib.mjs';
+
+export const DEFAULT_STATE_LOCK_TIMEOUT_MS = 10 * 60 * 1000;
+export const DEFAULT_STATE_LOCK_STALE_MS = 15 * 60 * 1000;
+export const DEFAULT_STATE_LOCK_POLL_MS = 250;
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+/** Absolute path of the lock directory backing `name`. */
+export const resolveStateLockPath = (name, env = process.env) => path.join(resolveBotStateDir(env), `${name}.lock`);
+
+/**
+ * Run `fn` while holding the named state lock.
+ *
+ * @param {string} name - Lock name, e.g. `formal-ai-sidecar`.
+ * @param {() => Promise<any>} fn - Critical section.
+ * @returns {Promise<any>} Whatever `fn` resolves to.
+ */
+export const withStateLock = async (name, fn, { env = process.env, fsImpl = fs, now = () => Date.now(), timeoutMs = DEFAULT_STATE_LOCK_TIMEOUT_MS, staleMs = DEFAULT_STATE_LOCK_STALE_MS, pollMs = DEFAULT_STATE_LOCK_POLL_MS, sleepImpl = sleep, log = null } = {}) => {
+  const lockPath = resolveStateLockPath(name, env);
+  fsImpl.mkdirSync(path.dirname(lockPath), { recursive: true });
+
+  const deadline = now() + timeoutMs;
+  for (;;) {
+    try {
+      fsImpl.mkdirSync(lockPath);
+      break;
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+
+      let age;
+      try {
+        age = now() - fsImpl.statSync(lockPath).mtimeMs;
+      } catch {
+        // The holder released it between mkdir and stat; retry immediately.
+        continue;
+      }
+
+      if (age > staleMs) {
+        if (log) await log(`⚠️ ${name} lock held for ${Math.round(age / 1000)}s with no owner; breaking it`);
+        try {
+          fsImpl.rmSync(lockPath, { recursive: true, force: true });
+        } catch {
+          // Another waiter won the race; retry normally.
+        }
+        continue;
+      }
+
+      if (now() >= deadline) throw new Error(`Timed out after ${Math.round(timeoutMs / 1000)}s waiting for the ${name} lock at ${lockPath}`, { cause: error });
+      await sleepImpl(pollMs);
+    }
+  }
+
+  try {
+    return await fn();
+  } finally {
+    try {
+      fsImpl.rmSync(lockPath, { recursive: true, force: true });
+    } catch {
+      // Losing the release is recoverable through the stale-lock path above.
+    }
+  }
+};
+
+export default { DEFAULT_STATE_LOCK_POLL_MS, DEFAULT_STATE_LOCK_STALE_MS, DEFAULT_STATE_LOCK_TIMEOUT_MS, resolveStateLockPath, withStateLock };