@link-assistant/hive-mind 2.8.8 → 2.8.9

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @link-assistant/hive-mind
 
+## 2.8.9
+
+### Patch Changes
+
+- fd1789e: fix(development-log): collect a development log for every working session (#2090)
+
+  A run with `--auto-restart-until-mergeable` (implied by `--auto-merge`) starts a
+  new tool session with its own session UUID per restart iteration, but only the
+  first session ever reached the pull request:
+  `createDevelopmentLogFinalizer` memoized a single collection per process, no
+  restart path invoked the finalizer again, and several exit paths (usage limit,
+  tool failure, graceful shutdown, auto-continue) skipped finalization entirely.
+  The single collected `solve.log` was also truncated at collection time and was
+  committed twice, as a byte-identical duplicate under `<tool>-<sessionId>.log`.
+
+  The finalizer is now memoized per session id, every restart iteration finalizes
+  its own session at the shared `executeToolIteration` chokepoint, `safeExit`
+  forces a final collection on every exit path, and each session directory stores
+  only its own byte range of the process log (`metadata.json` schema version 3,
+  `artifacts.solveLogRange`) so the union of the sessions is the complete log
+  without duplication.
+
 ## 2.8.8
 
 ### Patch Changes

package/package.json

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

package/src/development-log.finalize.lib.mjs

@@ -1,11 +1,105 @@
 /**
- * Build a once-only finalizer so both the normal and error completion paths can
- * preserve a development log without creating duplicate commits.
+ * Build a per-session finalizer so every completion path can preserve a
+ * development log without creating duplicate commits.
+ *
+ * Issue #1596 introduced a once-only finalizer: the first call collected the
+ * artifacts and every later call reused the memoized promise. Issue #2090
+ * showed that this silently drops every session after the first one — a run
+ * with `--auto-restart-until-mergeable` starts a brand new tool session (a new
+ * session UUID) per restart iteration, but only the very first session ever
+ * reached the repository.
+ *
+ * The finalizer is therefore memoized *per session id* instead of per process:
+ *
+ * - the same session id is collected only once (no duplicate commits),
+ * - a different session id is collected again into its own `sessions/<uuid>/`
+ *   directory,
+ * - each collection copies only the slice of the solve log that was produced
+ *   since the previous collection, so the union of all session directories is
+ *   the complete process log without duplicating megabytes per session.
  */
-export const createDevelopmentLogFinalizer = ({ collect, getParams }) => {
-  let resultPromise = null;
-  return () => {
-    if (!resultPromise) resultPromise = Promise.resolve().then(() => collect(getParams()));
+export const createDevelopmentLogFinalizer = ({ collect, getParams, register = true }) => {
+  // sessionKey -> promise of the collection result (dedupe per session).
+  const collections = new Map();
+  // sessionKey -> { startByte, sessionId } of an already collected session.
+  const sessionStartBytes = new Map();
+  // Byte offset in the solve log right after the last collected slice.
+  let nextLogStartByte = 0;
+  // Key of the session collected most recently, so a forced finalize at exit
+  // extends *that* session's log slice instead of re-collecting the first one.
+  let lastSessionKey = null;
+  // Serializes collections so their log slices never interleave.
+  let queue = Promise.resolve();
+
+  const toKey = sessionId => (sessionId ? String(sessionId) : '__no-session__');
+
+  const finalize = (options = {}) => {
+    const params = { ...getParams() };
+    if (options.sessionId !== undefined && options.sessionId !== null) params.sessionId = options.sessionId;
+
+    let sessionKey = toKey(params.sessionId);
+    if (options.force && options.sessionId === undefined && lastSessionKey) {
+      // Exit-time collection: the log tail belongs to the session collected
+      // most recently (which is a restart-iteration session, not the first one
+      // still referenced by the caller's `sessionId` variable).
+      sessionKey = lastSessionKey;
+      params.sessionId = sessionStartBytes.get(sessionKey)?.sessionId ?? params.sessionId;
+    }
+    const alreadyCollected = collections.has(sessionKey);
+
+    // Re-collecting the same session is only useful when the caller explicitly
+    // asks for it (process exit, to capture the log tail produced after the
+    // session finished). Otherwise reuse the memoized result.
+    if (alreadyCollected && !options.force) return collections.get(sessionKey);
+
+    lastSessionKey = sessionKey;
+
+    // Collections are serialized: each one commits and pushes, and the log
+    // slice boundaries only make sense when resolved sequentially.
+    const resultPromise = queue
+      .catch(() => {})
+      .then(() => {
+        const known = sessionStartBytes.get(sessionKey);
+        const logStartByte = known ? known.startByte : nextLogStartByte;
+        sessionStartBytes.set(sessionKey, { startByte: logStartByte, sessionId: params.sessionId ?? null });
+        return collect({ ...params, logStartByte });
+      })
+      .then(result => {
+        const endByte = result?.logEndByte;
+        if (typeof endByte === 'number' && endByte > nextLogStartByte) nextLogStartByte = endByte;
+        return result;
+      });
+
+    queue = resultPromise.catch(() => {});
+    collections.set(sessionKey, resultPromise);
     return resultPromise;
   };
+
+  finalize.getCollectedSessionKeys = () => [...collections.keys()];
+  // Publish the finalizer so restart iterations (watch mode,
+  // auto-restart-until-mergeable, keep-working, escalation, auto-ensure) and
+  // every exit path can collect the session they just finished.
+  if (register) setActiveDevelopmentLogFinalizer(finalize);
+  return finalize;
+};
+
+// Module-level registry so restart iterations deep in the call tree (watch
+// mode, auto-restart-until-mergeable, keep-working, escalation, auto-ensure)
+// can finalize the development log of the session they just finished without
+// threading the finalizer through every call signature.
+let activeFinalizer = null;
+
+export const setActiveDevelopmentLogFinalizer = finalizer => {
+  activeFinalizer = typeof finalizer === 'function' ? finalizer : null;
+};
+
+export const getActiveDevelopmentLogFinalizer = () => activeFinalizer;
+
+export const finalizeActiveDevelopmentLog = async (options = {}) => {
+  if (!activeFinalizer) return { skipped: 'no-active-finalizer' };
+  try {
+    return await activeFinalizer(options);
+  } catch (error) {
+    return { skipped: 'error', error };
+  }
 };

package/src/development-log.lib.mjs

@@ -1,6 +1,8 @@
 import fs from 'node:fs/promises';
+import { createReadStream, createWriteStream } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { pipeline } from 'node:stream/promises';
 
 const sanitizePathSegment = (value, fallback) => {
   const raw = value === null || value === undefined || value === '' ? fallback : String(value);
@@ -113,6 +115,23 @@ const findCodexSessionFile = async ({ sessionId, homeDir }) => {
   }
 };
 
+// Copy a byte range of the solve log into the session directory.
+// Issue #2090: each session stores only the slice of the process log that was
+// produced while that session was running, so the union of all session
+// directories is the complete log instead of N truncated copies of the same
+// prefix. Returns the byte offset right after the copied slice.
+const copyLogSlice = async ({ logFile, destinationPath, logStartByte = 0 }) => {
+  const stat = await fs.stat(logFile);
+  // The log was rotated/truncated since the previous collection: copy it whole.
+  const start = Number.isFinite(logStartByte) && logStartByte > 0 && logStartByte <= stat.size ? logStartByte : 0;
+  if (stat.size === 0 || start >= stat.size) {
+    await fs.writeFile(destinationPath, '');
+    return { logStartByte: start, logEndByte: stat.size };
+  }
+  await pipeline(createReadStream(logFile, { start, end: stat.size - 1 }), createWriteStream(destinationPath));
+  return { logStartByte: start, logEndByte: stat.size };
+};
+
 const copyKnownSessionFiles = async ({ repositoryPath, sessionRelativeDirectory, logFile, sessionId, tool, homeDir }) => {
   if (!sessionId) return [];
 
@@ -149,9 +168,16 @@ const copyKnownSessionFiles = async ({ repositoryPath, sessionRelativeDirectory,
 
   const copied = [];
   const seenSources = new Set();
+  // Issue #2090: when the tool renamed the running solve log to
+  // `<sessionId>.log`, this candidate resolves to the very log file that is
+  // already copied as solve.log — copying it again duplicated megabytes per
+  // session (PR link-assistant/formal-ai#809 stored two byte-identical 7 MB
+  // files). Skip it instead.
+  const resolvedLogFile = logFile ? path.resolve(logFile) : null;
   for (const candidate of candidates) {
     if (!candidate.sourcePath || seenSources.has(candidate.sourcePath)) continue;
     seenSources.add(candidate.sourcePath);
+    if (resolvedLogFile && path.resolve(candidate.sourcePath) === resolvedLogFile) continue;
 
     const relativePath = `${sessionRelativeDirectory}/${safeFileName(candidate.destinationName)}`;
     const copiedPath = path.join(sessionDirectory, safeFileName(candidate.destinationName));
@@ -163,7 +189,7 @@ const copyKnownSessionFiles = async ({ repositoryPath, sessionRelativeDirectory,
   return copied;
 };
 
-export const writeDevelopmentLogArtifacts = async ({ repositoryPath, logFile, issueNumber, prNumber, tool, sessionId, branchName, rawCommand, now = new Date(), homeDir = os.homedir() }) => {
+export const writeDevelopmentLogArtifacts = async ({ repositoryPath, logFile, issueNumber, prNumber, tool, sessionId, branchName, rawCommand, logStartByte = 0, now = new Date(), homeDir = os.homedir() }) => {
   if (!repositoryPath) {
     throw new Error('repositoryPath is required to write development-log artifacts');
   }
@@ -179,9 +205,14 @@ export const writeDevelopmentLogArtifacts = async ({ repositoryPath, logFile, is
   await fs.mkdir(sessionDirectory, { recursive: true });
 
   let copiedLogRelativePath = null;
+  let logSlice = { logStartByte: 0, logEndByte: 0 };
   if (logFile) {
     copiedLogRelativePath = `${sessionRelativeDirectory}/solve.log`;
-    await fs.copyFile(logFile, path.join(repositoryPath, copiedLogRelativePath));
+    logSlice = await copyLogSlice({
+      logFile,
+      destinationPath: path.join(repositoryPath, copiedLogRelativePath),
+      logStartByte,
+    });
   }
 
   const sessionFiles = await copyKnownSessionFiles({
@@ -195,7 +226,9 @@ export const writeDevelopmentLogArtifacts = async ({ repositoryPath, logFile, is
 
   const metadataRelativePath = `${sessionRelativeDirectory}/metadata.json`;
   const metadata = {
-    schemaVersion: 2,
+    // v3 (issue #2090): one directory per tool session, `solve.log` holds only
+    // this session's slice of the process log (see solveLogRange).
+    schemaVersion: 3,
     collectedAt: now.toISOString(),
     issueNumber: issueNumber ?? null,
     prNumber: prNumber ?? null,
@@ -207,6 +240,7 @@ export const writeDevelopmentLogArtifacts = async ({ repositoryPath, logFile, is
     caseStudyDirectory,
     artifacts: {
       solveLog: copiedLogRelativePath ? addDotSlash(toPosixPath(copiedLogRelativePath)) : null,
+      solveLogRange: copiedLogRelativePath ? { startByte: logSlice.logStartByte, endByte: logSlice.logEndByte } : null,
       sessionFiles,
     },
   };
@@ -221,12 +255,14 @@ export const writeDevelopmentLogArtifacts = async ({ repositoryPath, logFile, is
     copiedLogRelativePath: copiedLogRelativePath ? toPosixPath(copiedLogRelativePath) : null,
     metadataRelativePath: toPosixPath(metadataRelativePath),
     sessionFiles,
+    logStartByte: logSlice.logStartByte,
+    logEndByte: logSlice.logEndByte,
   };
 };
 
 const getCommandOutput = result => (result?.stderr?.toString?.() || result?.stdout?.toString?.() || '').trim();
 
-export const collectAndCommitDevelopmentLogArtifacts = async ({ enabled, repositoryPath, logFile, issueNumber, prNumber, tool, sessionId, branchName, rawCommand, $, log }) => {
+export const collectAndCommitDevelopmentLogArtifacts = async ({ enabled, repositoryPath, logFile, issueNumber, prNumber, tool, sessionId, branchName, rawCommand, logStartByte = 0, $, log }) => {
   if (!enabled) {
     return { skipped: 'disabled' };
   }
@@ -237,7 +273,7 @@ export const collectAndCommitDevelopmentLogArtifacts = async ({ enabled, reposit
   }
 
   // Issue #2048: verbose trace so the commit timing (relative to PR readiness signals) is diagnosable from logs.
-  await log?.(`🔍 Development log finalize: issue #${issueNumber ?? '?'}, PR #${prNumber ?? 'pending'}, branch ${branchName ?? 'none'}, session ${sessionId ?? 'none'}`, { verbose: true });
+  await log?.(`🔍 Development log finalize: issue #${issueNumber ?? '?'}, PR #${prNumber ?? 'pending'}, branch ${branchName ?? 'none'}, session ${sessionId ?? 'none'}, log slice from byte ${logStartByte}`, { verbose: true });
 
   try {
     const artifacts = await writeDevelopmentLogArtifacts({
@@ -249,8 +285,10 @@ export const collectAndCommitDevelopmentLogArtifacts = async ({ enabled, reposit
       sessionId,
       branchName,
       rawCommand,
+      logStartByte,
     });
 
+    await log?.(`🧾 Development log artifacts written to ${artifacts.sessionRelativeDirectory} (log bytes ${artifacts.logStartByte}-${artifacts.logEndByte})`, { verbose: true });
     await log?.(`🧾 Development log artifacts written to ${artifacts.developmentLogDirectory}`);
 
     if (!$) {

package/src/exit-handler.lib.mjs

@@ -9,6 +9,11 @@
 // Issue #1823: working-session guard for --do-not-shutdown-in-the-middle-of-working-session.
 // Static import is safe: working-session.lib.mjs has no heavy deps and does NOT import this module.
 import { isFlagEnabled as isWorkingSessionFlagEnabled, isWorkingSessionActive, requestShutdown as requestWorkingSessionShutdown, forceKillActiveChildren as forceKillWorkingSessionChildren } from './working-session.lib.mjs';
+// Issue #2090: preserve the development log on every exit path (usage limit
+// reached, tool failure, repository setup failure, graceful shutdown,
+// auto-continue hand-off). No-op unless solve registered a finalizer, so hive
+// and other consumers of this module are unaffected.
+import { finalizeActiveDevelopmentLog } from './development-log.finalize.lib.mjs';
 
 // Lazy-load Sentry to avoid keeping the event loop alive when not needed
 let Sentry = null;
@@ -241,6 +246,10 @@ export const logActiveHandles = async (log = null) => {
 export const safeExit = async (code = 0, reason = 'Process completed', { skipPreExit = false, failureActionSection = null } = {}) => {
   await showExitMessage(reason, code);
 
+  // Issue #2090: collect the working session that is still uncollected (and the
+  // log tail produced after it) before the process goes away.
+  await finalizeActiveDevelopmentLog({ force: true });
+
   if (!skipPreExit && code !== 0 && preExitFunction && !preExitHandlerRan) {
     preExitHandlerRan = true;
     try {

package/src/solve.restart-shared.lib.mjs

@@ -476,6 +476,18 @@ export const executeToolIteration = async params => {
     diskPath: '/',
     label: 'after AI restart iteration',
   });
+
+  // Issue #2090: every restart iteration starts a brand new tool session with
+  // its own session UUID. Collect its development log here — this is the single
+  // chokepoint shared by watch mode, auto-restart-until-mergeable,
+  // keep-working, escalation and auto-ensure — otherwise only the very first
+  // session of the process ever reached the pull request.
+  // When the tool did not report a session id there is nothing to key a new
+  // directory on, so extend the previously collected session instead of losing
+  // this iteration's part of the log.
+  const { finalizeActiveDevelopmentLog } = await import('./development-log.finalize.lib.mjs');
+  await (toolResult?.sessionId ? finalizeActiveDevelopmentLog({ sessionId: toolResult.sessionId }) : finalizeActiveDevelopmentLog({ force: true }));
+
   return toolResult;
 };