@link-assistant/hive-mind 2.11.13 → 2.12.0

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 };

package/src/telegram-bot.mjs

@@ -263,6 +263,7 @@ const { createSessionStore } = await import('./session-store.lib.mjs');
 const { createHeartbeat, resumeSessionsOnLaunch, createShutdownHandler } = await import('./bot-lifecycle.lib.mjs');
 const { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } = await import('./work-session-formatting.lib.mjs');
 const { buildTelegramHelpMessage, buildTelegramInfoBlock, buildSolveQueuedMessage } = await import('./telegram-ui-messages.lib.mjs');
+const { startFormalAiMaintenance } = await import('./formal-ai-maintenance.lib.mjs');
 
 // Initialize Sentry for error tracking
 await initializeSentry({
@@ -1244,6 +1245,7 @@ if (VERBOSE) {
 // Non-retryable errors (401 Unauthorized) cause immediate exit.
 const launchAbortController = new AbortController();
 let sessionMonitoringTimer = null;
+let formalAiMaintenance = null;
 let launchAnnouncementShown = false;
 
 function startSessionMonitoringOnce() {
@@ -1253,6 +1255,20 @@ function startSessionMonitoringOnce() {
   sessionMonitoringTimer = startSessionMonitoring(bot, VERBOSE, 30000, { isolationRunner });
 }
 
+// Issue #2146 (PR #2147 review): stop the Formal AI sidecar once no Formal AI
+// task holds a lease, then — while the host is idle — update its image (with a
+// non-destructive memory migration) and refresh the agentic CLIs. Every step is
+// best-effort and never blocks the bot.
+function startFormalAiMaintenanceOnce() {
+  if (formalAiMaintenance) return;
+  formalAiMaintenance = startFormalAiMaintenance({
+    verbose: VERBOSE,
+    log: async message => {
+      console.log(message);
+    },
+  });
+}
+
 // Issue #1927 (requirements #3/#4): a periodic timestamped heartbeat so the "last
 // time the bot was alive" is always discoverable from the log. The heartbeat
 // logic lives in bot-lifecycle.lib.mjs so it can be unit tested.
@@ -1274,6 +1290,7 @@ async function onBotLaunched() {
   await resumeSessionsOnLaunch({ resumeTrackedSessions, botStartTime: BOT_START_TIME, verbose: VERBOSE, logger: botLogger });
 
   startSessionMonitoringOnce();
+  startFormalAiMaintenanceOnce();
   heartbeat.start();
 
   if (VERBOSE) {
@@ -1372,6 +1389,7 @@ const handleShutdownSignal = createShutdownHandler({
   cleanup: () => {
     launchAbortController.abort();
     if (sessionMonitoringTimer) clearInterval(sessionMonitoringTimer);
+    formalAiMaintenance?.stop();
     heartbeat.stop();
     stopSolveQueue();
   },

package/src/telegram-fix-command.lib.mjs

@@ -10,6 +10,7 @@
 import { buildUserMention } from './buildUserMention.lib.mjs';
 import { validateModelName } from './models/index.mjs';
 import { parseFixRepository } from './fix.ci-cd.lib.mjs';
+import { getModelFromArgs } from './model-args.lib.mjs';
 import { escapeMarkdown } from './telegram-markdown.lib.mjs';
 import { extractIsolationFromArgs, isValidPerCommandIsolation } from './telegram-isolation.lib.mjs';
 import { mergeArgsWithOverrides } from './args-overrides.lib.mjs';
@@ -47,14 +48,6 @@ export function getFixToolFromArgs(args) {
   return 'claude';
 }
 
-function getModelFromArgs(args) {
-  for (let i = 0; i < args.length; i++) {
-    if ((args[i] === '--model' || args[i] === '-m') && i + 1 < args.length) return args[i + 1];
-    if (args[i].startsWith('--model=')) return args[i].substring('--model='.length);
-  }
-  return null;
-}
-
 function validateFixModel(args) {
   const model = getModelFromArgs(args);
   if (!model) return null;

package/src/telegram-task-command.lib.mjs

@@ -1,6 +1,7 @@
 import { buildUserMention } from './buildUserMention.lib.mjs';
 import { validateModelName } from './models/index.mjs';
 import { getLinoYargsFactory } from './cli-arguments.lib.mjs';
+import { getModelFromArgs } from './model-args.lib.mjs';
 import { createYargsConfig as createTaskYargsConfig } from './task.config.lib.mjs';
 import { createCiCdIssue } from './fix.ci-cd-issue.lib.mjs';
 import { parseFixRepository } from './fix.ci-cd.lib.mjs';
@@ -47,14 +48,6 @@ export function getTaskToolFromArgs(args) {
   return 'claude';
 }
 
-function getModelFromArgs(args) {
-  for (let i = 0; i < args.length; i++) {
-    if ((args[i] === '--model' || args[i] === '-m') && i + 1 < args.length) return args[i + 1];
-    if (args[i].startsWith('--model=')) return args[i].substring('--model='.length);
-  }
-  return null;
-}
-
 function validateTaskModel(args) {
   const model = getModelFromArgs(args);
   if (!model) return null;

package/src/working-session-summary.lib.mjs

@@ -49,6 +49,52 @@ export const redactWorkspacePaths = text => {
   return text.replace(WORKSPACE_PATH_PATTERN, WORKSPACE_PATH_PLACEHOLDER);
 };
 
+/**
+ * Fence structured text emitted after a Markdown lead-in ending in `:`.
+ * Formal AI plan events use a root record followed by space/tab-indented Lino;
+ * GitHub otherwise collapses that layout into ordinary prose. Existing fences
+ * and ordinary Markdown are preserved, making this safe to apply at the final
+ * GitHub-comment boundary.
+ */
+export const formatWorkingSessionSummaryMarkdown = text => {
+  if (typeof text !== 'string' || !text) return text;
+
+  const lines = text.split('\n');
+  const output = [];
+  let inFence = false;
+  let previousNonEmpty = '';
+
+  for (let index = 0; index < lines.length; ) {
+    const line = lines[index];
+    if (/^\s*(```|~~~)/.test(line)) {
+      inFence = !inFence;
+      output.push(line);
+      if (line.trim()) previousNonEmpty = line;
+      index += 1;
+      continue;
+    }
+
+    if (!inFence && line.trim() && previousNonEmpty.trimEnd().endsWith(':')) {
+      let end = index;
+      while (end < lines.length && lines[end].trim()) end += 1;
+      const block = lines.slice(index, end);
+      const looksStructured = block.length >= 2 && block.some(blockLine => /^(?:\t| {2,})/.test(blockLine));
+      if (looksStructured) {
+        output.push('```text', ...block, '```');
+        previousNonEmpty = '```';
+        index = end;
+        continue;
+      }
+    }
+
+    output.push(line);
+    if (line.trim()) previousNonEmpty = line;
+    index += 1;
+  }
+
+  return output.join('\n');
+};
+
 /**
  * The line appended when the pull request still has an empty diff.
  *
@@ -62,4 +108,4 @@ export const buildNoChangesNotice = changeStats => {
   return '> ⚠️ This pull request still contains no changes - nothing was implemented yet.';
 };
 
-export default { buildNoChangesNotice, redactWorkspacePaths, WORKSPACE_PATH_PLACEHOLDER };
+export default { buildNoChangesNotice, formatWorkingSessionSummaryMarkdown, redactWorkspacePaths, WORKSPACE_PATH_PLACEHOLDER };