@link-assistant/hive-mind 2.0.19 → 2.0.20

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 2.0.20
+
+### Patch Changes
+
+- 078f346: Reap successful Docker-isolated task containers at session completion, keep failed containers with cleanup instructions by default, and update Docker images to start-command 0.30.1.
+
 ## 2.0.19
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.0.19",
+  "version": "2.0.20",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/isolation-runner.lib.mjs

@@ -831,6 +831,47 @@ export async function checkDockerContainerRunning(containerName, verbose = false
   }
 }
 
+/**
+ * Best-effort removal for a Docker container backing a native
+ * `$ --isolated docker` session.
+ *
+ * start-command names the container after the `--session` value. The monitor
+ * calls this only after the session is terminal and after the host-side log has
+ * been inspected, so removing the container reclaims its writable layer without
+ * losing the captured task log. Never throws: completion notification must not
+ * fail just because Docker already removed the container.
+ *
+ * @param {string} containerName - Container name (the session UUID)
+ * @param {boolean} [verbose] - Enable verbose logging
+ * @returns {Promise<{success: boolean, output: string, error: string|null}>}
+ */
+export async function removeDockerContainer(containerName, verbose = false) {
+  if (!containerName) {
+    return { success: false, output: '', error: 'missing container name' };
+  }
+
+  try {
+    const result = await $({ mirror: false })`docker rm -f ${containerName}`;
+    const stdout = result.stdout?.toString() || '';
+    const stderr = result.stderr?.toString() || '';
+    if (verbose) {
+      console.log(`[VERBOSE] isolation-runner: docker rm -f '${containerName}' succeeded`);
+    }
+    return { success: true, output: stdout || stderr, error: null };
+  } catch (error) {
+    const stderr = error?.stderr?.toString?.() || '';
+    const stdout = error?.stdout?.toString?.() || '';
+    if (verbose) {
+      console.log(`[VERBOSE] isolation-runner: docker rm -f '${containerName}' failed: ${stderr.trim() || error?.message || error}`);
+    }
+    return {
+      success: false,
+      output: stdout,
+      error: stderr.trim() || error?.message || String(error),
+    };
+  }
+}
+
 /**
  * Check whether a tmux session with the given name still exists.
  * `tmux has-session -t <name>` exits 0 when it exists and non-zero otherwise,

package/src/session-monitor.lib.mjs

@@ -110,6 +110,20 @@ export function getIsolationSessionStateForTests(sessionName, sessionInfo, optio
  * mechanism will no longer be needed.
  */
 export const NON_ISOLATION_SESSION_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+export const DEFAULT_DOCKER_TASK_CONTAINER_KEEP_POLICY = 'on-failure';
+export const DOCKER_TASK_CONTAINER_KEEP_POLICIES = ['always', 'on-failure', 'never'];
+
+export function resolveDockerTaskContainerKeepPolicy({ env = process.env, verbose = false } = {}) {
+  const raw = String(env?.HIVE_MIND_KEEP_TASK_CONTAINER || '')
+    .trim()
+    .toLowerCase();
+  if (!raw) return DEFAULT_DOCKER_TASK_CONTAINER_KEEP_POLICY;
+  if (DOCKER_TASK_CONTAINER_KEEP_POLICIES.includes(raw)) return raw;
+  if (verbose) {
+    console.log(`[VERBOSE] Invalid HIVE_MIND_KEEP_TASK_CONTAINER='${raw}', using '${DEFAULT_DOCKER_TASK_CONTAINER_KEEP_POLICY}'`);
+  }
+  return DEFAULT_DOCKER_TASK_CONTAINER_KEEP_POLICY;
+}
 
 /**
  * Check if a screen session exists
@@ -345,6 +359,70 @@ async function buildDiskDiagnosticsExtraSection(logPath, { verbose = false, read
   }
 }
 
+function isSuccessfulTaskCompletion({ exitCode = null, status = null } = {}) {
+  const outcome = classifySessionOutcome({ exitCode, status });
+  if (outcome.failed) return false;
+  if (exitCode === 0) return true;
+
+  const normalizedStatus = String(status || '')
+    .trim()
+    .toLowerCase();
+  return exitCode === null && (normalizedStatus === 'executed' || normalizedStatus === 'completed');
+}
+
+function formatDockerTaskContainerKeptSection({ containerName, keepPolicy }) {
+  return ['*Docker container kept*', `Container: \`${containerName}\``, `Policy: \`HIVE_MIND_KEEP_TASK_CONTAINER=${keepPolicy}\``, `Inspect: \`docker start -ai ${containerName}\``, `Shell: \`docker exec -it ${containerName} sh\``, `Remove when done: \`docker rm -f ${containerName}\``].join('\n');
+}
+
+export function buildDockerTaskContainerCompletionAction({ sessionName, sessionInfo, exitCode = null, status = null, env = process.env, verbose = false } = {}) {
+  if (sessionInfo?.isolationBackend !== 'docker') {
+    return { applies: false, containerName: null, keepPolicy: null, shouldRemove: false, extraSection: '' };
+  }
+
+  const containerName = sessionInfo.sessionId || sessionName || null;
+  if (!containerName) {
+    return { applies: false, containerName: null, keepPolicy: null, shouldRemove: false, extraSection: '' };
+  }
+
+  const keepPolicy = resolveDockerTaskContainerKeepPolicy({ env, verbose });
+  const successful = isSuccessfulTaskCompletion({ exitCode, status });
+  const shouldKeep = keepPolicy === 'always' || (keepPolicy === 'on-failure' && !successful);
+
+  return {
+    applies: true,
+    containerName,
+    keepPolicy,
+    successful,
+    shouldRemove: !shouldKeep,
+    extraSection: shouldKeep ? formatDockerTaskContainerKeptSection({ containerName, keepPolicy }) : '',
+  };
+}
+
+async function applyDockerTaskContainerCompletionAction(action, { verbose = false, removeDockerContainer = null } = {}) {
+  if (!action?.applies || !action.shouldRemove || !action.containerName) return;
+
+  try {
+    const removeFn =
+      removeDockerContainer ||
+      (async (containerName, removeVerbose) => {
+        const runner = await getIsolationRunner();
+        return runner.removeDockerContainer(containerName, removeVerbose);
+      });
+    const result = await removeFn(action.containerName, verbose);
+    if (verbose) {
+      if (result?.success) {
+        console.log(`[VERBOSE] Removed docker task container '${action.containerName}' after terminal session completion`);
+      } else {
+        console.log(`[VERBOSE] Could not remove docker task container '${action.containerName}': ${result?.error || 'unknown error'}`);
+      }
+    }
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] Could not remove docker task container '${action.containerName}': ${error?.message || error}`);
+    }
+  }
+}
+
 function isNonIsolationSessionActive(sessionName, sessionInfo, verbose = false) {
   const startTime = sessionInfo.startTime instanceof Date ? sessionInfo.startTime : new Date(sessionInfo.startTime);
   const elapsed = Date.now() - startTime.getTime();
@@ -602,8 +680,17 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
     if (!stillRunning) {
       console.log(`Session ${sessionName} has finished. Sending notification to chat ${sessionInfo.chatId}`);
 
+      let dockerTaskContainerAction = null;
       try {
         const finalExitCode = getSessionCompletionExitCode({ exitCode, statusResult });
+        dockerTaskContainerAction = buildDockerTaskContainerCompletionAction({
+          sessionName,
+          sessionInfo,
+          exitCode: finalExitCode,
+          status: resolvedStatus,
+          env: options.env || process.env,
+          verbose,
+        });
 
         // Issue #1688/#1905: When the original /solve URL was an issue, look up
         //   the created PR so the completion message can include both an
@@ -709,6 +796,7 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
             console.log(`[VERBOSE] Could not build disk diagnostics section for ${sessionName}: ${diskError?.message || diskError}`);
           }
         }
+        const dockerTaskContainerExtraSections = dockerTaskContainerAction?.extraSection ? [dockerTaskContainerAction.extraSection] : [];
 
         const message = formatSessionCompletionMessage({
           sessionName,
@@ -718,7 +806,7 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
           exitCode: finalExitCode,
           infoBlock: sessionInfo?.infoBlock || '',
           pullRequestUrl,
-          extraSections: [...limitsExtraSections, ...resumeExtraSections, ...diskExtraSections],
+          extraSections: [...limitsExtraSections, ...resumeExtraSections, ...diskExtraSections, ...dockerTaskContainerExtraSections],
         });
 
         // Update the original reply message if messageId is available, otherwise send new message
@@ -758,10 +846,18 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
           }
         }
 
+        await applyDockerTaskContainerCompletionAction(dockerTaskContainerAction, {
+          verbose,
+          removeDockerContainer: options.removeDockerContainer,
+        });
         completeSession(sessionName, finalExitCode || 0, verbose, resolvedStatus);
       } catch (error) {
         console.error(`Failed to send completion notification for ${sessionName}:`, error);
         if (isMessageAlreadyUpdatedError(error)) {
+          await applyDockerTaskContainerCompletionAction(dockerTaskContainerAction, {
+            verbose,
+            removeDockerContainer: options.removeDockerContainer,
+          });
           completeSession(sessionName, exitCode || 0, verbose, resolvedStatus);
         } else {
           sessionInfo.lastNotificationError = error.message;