@link-assistant/hive-mind 2.8.7 → 2.8.9

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # @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
+
+- 2547914: fix(codex): repair the repository-scoped plugin cache before `codex exec` (#2088)
+
+  The #2084 preflight measured the right thing — it asked `codex debug
+prompt-input` which skills the model would receive — but had nowhere to go with
+  a negative answer: the provisioning step skipped `plugin add` whenever `codex
+plugin list` reported the plugin `installed, enabled`, and enablement
+  (`config.toml`) is independent of exposure (the materialized payload under
+  `plugins/cache/<marketplace>/<plugin>/<version>/skills`). A scoped `CODEX_HOME`
+  that lost its payload therefore logged "Continuing with the operator Codex
+  capabilities" and started the session without the mandated skills.
+
+  The preflight now inspects the scoped payload directly, repairs it through an
+  escalating ladder (`install` → `reinstall` → `copy-operator-payload`), re-probes
+  the rendered prompt in the exact environment `codex exec` receives, and forces
+  one rebuild when a required skill is still invisible. An explicitly declared
+  plugin or `plugin:skill` requirement that cannot be made visible now fails
+  closed before `codex exec` with a diagnostic naming the missing skills, the
+  expected cache path and every repair attempted; heuristically inferred
+  requirements still degrade safely (#2077). The CLI-agnostic half lives in the
+  new `src/agent-plugin-cache.lib.mjs` and is covered against both the Codex and
+  Claude Code plugin verbs, since Claude Code has the same enabled-vs-materialized
+  split.
+
 ## 2.8.7
 
 ### Patch Changes

package/package.json

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

package/src/agent-plugin-cache.lib.mjs

@@ -0,0 +1,176 @@
+/**
+ * Agent CLI plugin payload inspection and repair (issue #2088).
+ *
+ * Codex and Claude Code both install marketplace plugins into
+ *
+ *   <agent home>/plugins/cache/<marketplace>/<plugin>/<version>/
+ *
+ * and both expose a plugin's Agent Skills to the model only while that payload
+ * carries `skills/<skill>/SKILL.md`. Enablement is recorded separately — Codex
+ * in `config.toml`, Claude in its config — and neither CLI reconciles the two:
+ *
+ *   $ rm -rf "$HOME/plugins/cache/<marketplace>/<plugin>/<version>"
+ *   $ codex  plugin list --json   # installed: true, enabled: true
+ *   $ claude plugin list --json   # enabled: true, installPath: <deleted path>
+ *
+ * In both cases the model then receives a prompt with none of that plugin's
+ * skills. Any provisioning step that trusts `plugin list` therefore skips the
+ * one action that would fix it. Both CLIs re-materialize the payload when the
+ * install command is run again, and doing so is idempotent.
+ *
+ * Reproduced against the real CLIs in
+ * experiments/issue-2088/reproduce-cache-repair.sh (Codex) and
+ * experiments/issue-2088/reproduce-claude-cache-gap.sh (Claude Code).
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+// The install/remove verbs are the only part of the repair that is CLI
+// specific; the cache layout and the failure mode are identical.
+export const CODEX_PLUGIN_CLI = {
+  id: 'codex',
+  label: 'Codex',
+  install: pluginId => ['plugin', 'add', pluginId, '--json'],
+  remove: pluginId => ['plugin', 'remove', pluginId, '--json'],
+};
+
+export const CLAUDE_PLUGIN_CLI = {
+  id: 'claude',
+  label: 'Claude Code',
+  install: pluginId => ['plugin', 'install', pluginId],
+  remove: pluginId => ['plugin', 'uninstall', pluginId],
+};
+
+export const pluginIdParts = pluginId => {
+  const value = String(pluginId || '')
+    .trim()
+    .toLowerCase();
+  const separator = value.indexOf('@');
+  return separator === -1 ? { name: value, marketplace: '' } : { name: value.slice(0, separator), marketplace: value.slice(separator + 1) };
+};
+
+export const buildPluginCachePath = ({ agentHome, pluginId }) => {
+  const { name, marketplace } = pluginIdParts(pluginId);
+  return path.join(agentHome, 'plugins', 'cache', marketplace, name);
+};
+
+const listDirectoryNames = async directory => {
+  try {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    return entries.filter(entry => entry.isDirectory() || entry.isSymbolicLink()).map(entry => entry.name);
+  } catch {
+    return [];
+  }
+};
+
+/** The skills a plugin's materialized payload would actually expose, as `<plugin>:<skill>`. */
+export const readMaterializedPluginSkills = async ({ agentHome, pluginId }) => {
+  const root = buildPluginCachePath({ agentHome, pluginId });
+  const { name } = pluginIdParts(pluginId);
+  const skills = new Set();
+  const versions = await listDirectoryNames(root);
+  for (const version of versions) {
+    for (const skill of await listDirectoryNames(path.join(root, version, 'skills'))) {
+      try {
+        await fs.access(path.join(root, version, 'skills', skill, 'SKILL.md'));
+        skills.add(`${name}:${skill}`.toLowerCase());
+      } catch {
+        // A directory without SKILL.md is not a skill the CLI would render.
+      }
+    }
+  }
+  return { root, versions, skills };
+};
+
+/** `expectedSkills` maps a plugin id to the `<plugin>:<skill>` names that must be materialized. */
+export const inspectPluginPayloads = async ({ agentHome, plugins, expectedSkills = new Map() }) => {
+  const report = [];
+  for (const pluginId of plugins) {
+    const expected = expectedSkills.get(pluginId) || [];
+    const { root, versions, skills } = await readMaterializedPluginSkills({ agentHome, pluginId });
+    const missing = expected.filter(skill => !skills.has(skill));
+    report.push({ pluginId, root, versions, materialized: [...skills].sort(), missing, healthy: versions.length > 0 && missing.length === 0 });
+  }
+  return report;
+};
+
+/**
+ * Repair strategies, cheapest first: the first one that materializes the
+ * payload wins. `copyFrom` (the operator's own agent home) is the last resort
+ * for a scoped home that can no longer reach its marketplace source.
+ */
+export const buildPluginPayloadRepairs = ({ cli, onInstalled = async () => {}, onCopied = async () => {} }) => {
+  const install = async ({ command, env, runCommand, pluginId }) => {
+    const result = await runCommand({ command, args: cli.install(pluginId), env });
+    if (result?.code !== 0) throw new Error(`${command} ${cli.install(pluginId).join(' ')} exited with code ${result?.code}: ${String(result?.stderr || result?.stdout || '').trim()}`);
+    await onInstalled({ result, pluginId });
+    return result;
+  };
+
+  return [
+    { name: 'install', apply: install },
+    {
+      name: 'reinstall',
+      apply: async ({ command, env, runCommand, pluginId, agentHome }) => {
+        // Removal clears the enablement record together with the cache and is a
+        // no-op when the plugin is not installed.
+        await runCommand({ command, args: cli.remove(pluginId), env });
+        await fs.rm(buildPluginCachePath({ agentHome, pluginId }), { recursive: true, force: true });
+        await install({ command, env, runCommand, pluginId });
+      },
+    },
+    {
+      name: 'copy-operator-payload',
+      apply: async ({ pluginId, agentHome, copyFrom }) => {
+        if (!copyFrom) throw new Error(`No operator ${cli.label} home is available to copy ${pluginId} from.`);
+        const source = buildPluginCachePath({ agentHome: copyFrom, pluginId });
+        const operator = await readMaterializedPluginSkills({ agentHome: copyFrom, pluginId });
+        if (operator.versions.length === 0) throw new Error(`The operator ${cli.label} home has no materialized payload for ${pluginId} at ${source}.`);
+        const target = buildPluginCachePath({ agentHome, pluginId });
+        await fs.rm(target, { recursive: true, force: true });
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.cp(source, target, { recursive: true, dereference: true, force: true });
+        await onCopied({ pluginId, agentHome });
+      },
+    },
+  ];
+};
+
+/**
+ * Inspect, repair, re-inspect. `force: true` applies the first strategy even to
+ * a payload that looks healthy — used when a stronger signal (the rendered
+ * prompt) says the skills are still not reaching the model.
+ */
+export const repairPluginPayloads = async ({ command, env, runCommand, log = async () => {}, agentHome, copyFrom, plugins, expectedSkills, strategies, label = 'agent', force = false }) => {
+  const applied = [];
+  let report = await inspectPluginPayloads({ agentHome, plugins, expectedSkills });
+  for (const entry of report) {
+    await log(`   🔎 Scoped payload for ${entry.pluginId}: ${entry.versions.length} version(s), skills: ${entry.materialized.join(', ') || 'none'}`, { verbose: true });
+  }
+
+  for (const strategy of strategies) {
+    const unhealthy = report.filter(entry => force || !entry.healthy);
+    if (unhealthy.length === 0) break;
+    for (const entry of unhealthy) {
+      const reason = entry.versions.length === 0 ? 'payload not materialized' : entry.missing.length > 0 ? `payload missing ${entry.missing.join(', ')}` : 'model cannot see the required skills';
+      await log(`   🛠️  Repairing ${entry.pluginId} in ${label} state (${strategy.name}; ${reason})`);
+      try {
+        await strategy.apply({ command, env, runCommand, pluginId: entry.pluginId, agentHome, copyFrom });
+        applied.push(`${strategy.name}:${entry.pluginId}`);
+      } catch (error) {
+        await log(`   ⚠️  Repair step '${strategy.name}' failed for ${entry.pluginId}: ${error.message}`, { verbose: true });
+        applied.push(`${strategy.name}:${entry.pluginId} (failed)`);
+      }
+    }
+    force = false;
+    report = await inspectPluginPayloads({ agentHome, plugins, expectedSkills });
+    for (const entry of report) {
+      if (entry.healthy) await log(`   ✅ Materialized ${entry.pluginId} payload: ${entry.materialized.join(', ') || 'no skills'}`, { verbose: true });
+    }
+  }
+
+  return { report, applied, unhealthy: report.filter(entry => !entry.healthy) };
+};
+
+export default { CLAUDE_PLUGIN_CLI, CODEX_PLUGIN_CLI, buildPluginCachePath, buildPluginPayloadRepairs, inspectPluginPayloads, readMaterializedPluginSkills, repairPluginPayloads };

package/src/codex-capability-preflight.lib.mjs

@@ -13,6 +13,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 
+import { CODEX_PLUGIN_CLI, buildPluginCachePath as buildAgentPluginCachePath, buildPluginPayloadRepairs, pluginIdParts, readMaterializedPluginSkills as readAgentMaterializedPluginSkills, repairPluginPayloads } from './agent-plugin-cache.lib.mjs';
+
 const execFileAsync = promisify(execFile);
 const REQUIREMENT_WORDS = /\b(?:depend(?:s|ency)?|install|invoke|mandatory|must|need(?:ed|s)?|preflight|required?|requires|use)\b/i;
 const NEGATED_REQUIREMENT = /\b(?:does\s+not\s+require|not\s+required|optional)\b/i;
@@ -90,18 +92,26 @@ export function normalizePluginSelector(selector) {
 export function detectRequiredCodexCapabilities(text) {
   const plugins = new Set();
   const skills = new Set();
+  // Issue #2088: a fully qualified reference — `plugin@marketplace` in plugin
+  // context, or `plugin:skill` in requirement context — names a capability that
+  // prose cannot produce by accident, so an unrepairable failure for one of
+  // these is a real blocker. A bare `$name` or `` `name` skill `` token is a
+  // guess about free text and stays advisory, which keeps issue #2077's
+  // false-positive protection intact.
+  const explicit = new Set();
   // Every accepted capability keeps the line it came from so `--verbose` can
   // explain a detection instead of only reporting its consequence (issue #2077).
   const evidence = [];
   const rejected = [];
 
-  const accept = (target, value, line) => {
+  const accept = (target, value, line, { qualified = false } = {}) => {
     if (!isCapabilityName(value)) {
       rejected.push({ capability: value, line });
       return;
     }
     target.add(value);
-    evidence.push({ capability: value, line });
+    if (qualified) explicit.add(value);
+    evidence.push({ capability: value, line, explicit: qualified });
   };
 
   for (const rawLine of String(text || '').split(/\r?\n/u)) {
@@ -110,20 +120,22 @@ export function detectRequiredCodexCapabilities(text) {
 
     for (const match of line.matchAll(PLUGIN_SELECTOR)) {
       const selector = normalizePluginSelector(match[1]);
-      if (hasExplicitPluginContext(line, match)) accept(plugins, selector, line);
+      if (hasExplicitPluginContext(line, match)) accept(plugins, selector, line, { qualified: true });
       else rejected.push({ capability: selector, line });
     }
     for (const match of line.matchAll(NAMESPACED_SKILL)) {
       const skill = match[1].toLowerCase();
-      if (hasExplicitCapabilityContext(line, match)) accept(skills, skill, line);
+      if (hasExplicitCapabilityContext(line, match)) accept(skills, skill, line, { qualified: true });
       else rejected.push({ capability: skill, line });
     }
     for (const match of line.matchAll(EXPLICIT_BARE_SKILL)) accept(skills, (match[1] || match[2]).toLowerCase(), line);
   }
 
-  return { plugins: [...plugins].sort(), skills: [...skills].sort(), evidence, rejected };
+  return { plugins: [...plugins].sort(), skills: [...skills].sort(), explicit: [...explicit].sort(), evidence, rejected };
 }
 
+export const isExplicitRequirement = (requirements, capability) => (requirements?.explicit || []).includes(String(capability || '').toLowerCase());
+
 const sanitizePathSegment = value => String(value || '').replace(/[^a-zA-Z0-9._-]/gu, '_');
 
 export function buildCodexCapabilityStatePath({ baseCodexHome, owner, repo }) {
@@ -195,19 +207,28 @@ const readModelVisibleSkills = async ({ command, env, runCommand, log }) => {
   return skills;
 };
 
-const verifyModelVisibleSkills = async ({ command, env, runCommand, log, requiredSkills }) => {
-  if (!requiredSkills || requiredSkills.length === 0) return;
+// `status: 'unknown'` keeps the probe advisory when it cannot run at all;
+// `status: 'missing'` is a fact about the prompt the model would receive.
+const checkModelVisibleSkills = async ({ command, env, runCommand, log, requiredSkills }) => {
+  if (!requiredSkills || requiredSkills.length === 0) return { status: 'satisfied', visible: null, missing: [] };
   const visible = await readModelVisibleSkills({ command, env, runCommand, log });
-  if (!visible) return;
+  if (!visible) return { status: 'unknown', visible: null, missing: [] };
 
   await log(`   🔎 Model-visible skills (${visible.size}): ${[...visible].sort().join(', ') || 'none'}`, { verbose: true });
-  const invisible = requiredSkills.filter(skill => !visible.has(skill.toLowerCase()));
-  if (invisible.length === 0) {
-    await log(`   ✅ Verified ${requiredSkills.length} required skill(s) are visible to the model`);
-    return;
-  }
+  const missing = requiredSkills.filter(skill => !visible.has(skill.toLowerCase()));
+  return { status: missing.length === 0 ? 'satisfied' : 'missing', visible, missing };
+};
+
+const skillVisibilityError = ({ missing, visible, requirements, repairs = [] }) => new CodexCapabilityPreflightError(`Codex reports the required plugins as installed, but the model cannot see: ${missing.join(', ')}. ` + `Codex exposes a plugin's skills only while its payload is materialized under ` + `CODEX_HOME/plugins/cache/<marketplace>/<plugin>/<version>/skills. ` + `Visible skills were: ${visible ? [...visible].sort().join(', ') || 'none' : 'unknown'}.` + (repairs.length > 0 ? ` Attempted repairs: ${repairs.join(', ')}.` : ''), { missing, failClosed: missing.some(skill => isExplicitRequirement(requirements, skill)) });
 
-  throw new CodexCapabilityPreflightError(`Codex reports the required plugins as installed, but the model cannot see: ${invisible.join(', ')}. ` + `Codex exposes a plugin's skills only while its payload is materialized under ` + `CODEX_HOME/plugins/cache/<marketplace>/<plugin>/<version>/skills. ` + `Visible skills were: ${[...visible].sort().join(', ') || 'none'}.`, { missing: invisible });
+const verifyModelVisibleSkills = async ({ command, env, runCommand, log, requiredSkills, requirements }) => {
+  const outcome = await checkModelVisibleSkills({ command, env, runCommand, log, requiredSkills });
+  if (outcome.status === 'unknown') return outcome;
+  if (outcome.status === 'satisfied') {
+    if (requiredSkills?.length) await log(`   ✅ Verified ${requiredSkills.length} required skill(s) are visible to the model`);
+    return outcome;
+  }
+  throw skillVisibilityError({ missing: outcome.missing, visible: outcome.visible, requirements });
 };
 
 const skillParts = skill => {
@@ -240,10 +261,14 @@ const skillExistsInDirectories = async (skill, skillDirectories) => {
   return false;
 };
 
-export async function resolveRequiredPlugins({ requirements, catalog, skillDirectories = [] }) {
+// Issue #2088: repairing a payload requires knowing *which* plugin is expected
+// to provide each required skill, so resolution reports the mapping rather than
+// only the set of plugin selectors.
+export async function resolveRequiredCapabilities({ requirements, catalog, skillDirectories = [] }) {
   const entries = catalogEntries(catalog);
   const byId = new Map(entries.map(entry => [normalizePluginSelector(entry.pluginId), entry]));
   const selected = new Map();
+  const providers = new Map();
   const missing = [];
 
   for (const selector of requirements.plugins || []) {
@@ -266,15 +291,29 @@ export async function resolveRequiredPlugins({ requirements, catalog, skillDirec
         break;
       }
     }
-    if (provider) selected.set(normalizePluginSelector(provider.pluginId), provider);
-    else missing.push(skill);
+    if (provider) {
+      selected.set(normalizePluginSelector(provider.pluginId), provider);
+      providers.set(skill, { pluginId: normalizePluginSelector(provider.pluginId), pluginName: provider.name || skillParts(skill).namespace, skillName: skillParts(skill).name });
+    } else missing.push(skill);
   }
 
   if (missing.length > 0) {
-    throw new CodexCapabilityPreflightError(`Required Codex capability unavailable: ${missing.join(', ')}. ` + `Run 'codex plugin list --available --json' in the operator container and configure a marketplace that provides it. ` + `Hive Mind installs discovered capabilities into repository-scoped CODEX_HOME state; it does not enable plugins globally.`, { missing });
+    // A missing capability that the issue named explicitly is a blocker; one
+    // inferred from prose is a guess that failed (issues #2077 and #2088).
+    // Only `plugin@marketplace` selectors qualify here: at this point nothing
+    // has corroborated the detection, and a `plugin:skill` token the catalog has
+    // never heard of is more likely a false positive (issue #2080) than a real
+    // requirement. Once the catalog *does* resolve the provider, a skill that
+    // repair cannot materialize does fail closed further down.
+    const explicitMissing = missing.filter(capability => isExplicitRequirement(requirements, capability) && capability.includes('@'));
+    throw new CodexCapabilityPreflightError(`Required Codex capability unavailable: ${missing.join(', ')}. ` + `Run 'codex plugin list --available --json' in the operator container and configure a marketplace that provides it. ` + `Hive Mind installs discovered capabilities into repository-scoped CODEX_HOME state; it does not enable plugins globally.`, { missing, failClosed: explicitMissing.length > 0 });
   }
 
-  return [...selected.keys()].sort();
+  return { plugins: [...selected.keys()].sort(), providers };
+}
+
+export async function resolveRequiredPlugins(options) {
+  return (await resolveRequiredCapabilities(options)).plugins;
 }
 
 const readIssueRequirementText = async ({ owner, repo, issueNumber, runCommand }) => {
@@ -349,8 +388,55 @@ const prepareScopedCodexHome = async ({ baseCodexHome, codexHome }) => {
   }
 };
 
+// --- issue #2088: repair the repository-scoped plugin payload ----------------
+//
+// `codex plugin list` reporting `installed, enabled` proves only that
+// `config.toml` declares the plugin and that Codex could resolve a source for
+// it. The skill loader reads
+// `CODEX_HOME/plugins/cache/<marketplace>/<plugin>/<version>/skills`, so a
+// scoped home whose cache is missing or stale exposes zero skills while every
+// enablement check passes. Reproduced end to end with a real Codex CLI in
+// experiments/issue-2088/reproduce-cache-repair.sh.
+
+export const buildPluginCachePath = ({ codexHome, pluginId }) => buildAgentPluginCachePath({ agentHome: codexHome, pluginId: normalizePluginSelector(pluginId) });
+
+export const readMaterializedPluginSkills = ({ codexHome, pluginId }) => readAgentMaterializedPluginSkills({ agentHome: codexHome, pluginId: normalizePluginSelector(pluginId) });
+
+// `codex plugin remove` also drops the `[plugins."…"]` block, so a payload
+// restored by copying it back in has to be re-declared to stay enabled.
+const enablePluginInScopedConfig = async ({ agentHome: codexHome, pluginId }) => {
+  const configPath = path.join(codexHome, 'config.toml');
+  const config = await readIfPresent(configPath);
+  if (new RegExp(`^\\[plugins\\."${pluginId.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&')}"\\]`, 'mu').test(config)) return;
+  await fs.writeFile(configPath, `${config.trimEnd()}\n\n[plugins."${pluginId}"]\nenabled = true\n`);
+};
+
+const PLUGIN_PAYLOAD_REPAIRS = buildPluginPayloadRepairs({
+  cli: CODEX_PLUGIN_CLI,
+  onInstalled: ({ result, pluginId }) => parseJsonCommand(result, `Installing required Codex plugin ${pluginId}`),
+  onCopied: enablePluginInScopedConfig,
+});
+
+// The provider map answers "which plugin must expose which skill", which is
+// what turns a payload listing into a health verdict.
+const expectedSkillsByPlugin = providers => {
+  const expected = new Map();
+  for (const provider of providers?.values() || []) {
+    const skill = `${pluginIdParts(provider.pluginId).name}:${provider.skillName}`.toLowerCase();
+    expected.set(provider.pluginId, [...(expected.get(provider.pluginId) || []), skill]);
+  }
+  return expected;
+};
+
+export const repairScopedPluginPayloads = ({ command, env, runCommand, log, codexHome, baseCodexHome, plugins, providers, strategies = PLUGIN_PAYLOAD_REPAIRS, force = false }) => repairPluginPayloads({ command, env, runCommand, log, agentHome: codexHome, copyFrom: baseCodexHome, plugins, expectedSkills: expectedSkillsByPlugin(providers), strategies, force, label: 'repository-scoped Codex' });
+
 export const isCodexCapabilityStrict = (env = process.env) => /^(?:1|true|yes|on)$/iu.test(String(env.HIVE_MIND_CODEX_CAPABILITY_STRICT || ''));
 
+// Issue #2088: explicitly declared capabilities fail closed. This escape hatch
+// restores the previous advisory-only behaviour for an operator who would
+// rather run degraded than not at all.
+export const isCodexCapabilityAdvisory = (env = process.env) => /^(?:1|true|yes|on)$/iu.test(String(env.HIVE_MIND_CODEX_CAPABILITY_ADVISORY || ''));
+
 export async function runCodexCapabilityPreflight(options = {}) {
   const { log = async () => {}, env = process.env } = options;
   try {
@@ -363,6 +449,15 @@ export async function runCodexCapabilityPreflight(options = {}) {
     // ratio (`16:9`) was read as a skill name. Degrade to a warning and let
     // Codex execute with the operator's own capabilities.
     if (isCodexCapabilityStrict(env)) throw error;
+    // Issue #2088: that reasoning does not extend to a capability the issue
+    // named explicitly and that repair could not materialize. Continuing there
+    // spends a full solver run that is already known to be unable to satisfy
+    // the task, so an explicit requirement fails closed before `codex exec`.
+    if (error.details?.failClosed && !isCodexCapabilityAdvisory(env)) {
+      await log(`❌ Codex capability preflight failed: ${error.message}`);
+      await log('   The issue names this capability explicitly, so Codex was not started. Set HIVE_MIND_CODEX_CAPABILITY_ADVISORY=1 to run degraded instead.');
+      throw error;
+    }
     await log(`⚠️  Codex capability preflight skipped: ${error.message}`);
     await log('   Continuing with the operator Codex capabilities. Set HIVE_MIND_CODEX_CAPABILITY_STRICT=1 to fail instead.');
     return { required: false, degraded: true, error: error.message, plugins: [], codexHome: null };
@@ -390,13 +485,13 @@ async function provisionCodexCapabilities({ owner, repo, issueNumber, projectDir
   const baseCatalogResult = await runCommand({ command, args: ['plugin', 'list', '--available', '--json'], env: baseEnv });
   const baseCatalog = parseJsonCommand(baseCatalogResult, 'Codex plugin catalog discovery');
   const skillDirectories = [path.join(os.homedir(), '.agents', 'skills'), projectDir && path.join(projectDir, '.agents', 'skills')].filter(Boolean);
-  const plugins = await resolveRequiredPlugins({ requirements, catalog: baseCatalog, skillDirectories });
+  const { plugins, providers } = await resolveRequiredCapabilities({ requirements, catalog: baseCatalog, skillDirectories });
   for (const plugin of plugins) {
     await log(`   ✅ Verified ${plugin} in the Codex plugin catalog`, { verbose: true });
   }
   if (plugins.length === 0) {
     await log('   ✅ Required Agent Skills are already available from standard skill directories');
-    await verifyModelVisibleSkills({ command, env: baseEnv, runCommand, log, requiredSkills: requirements.skills });
+    await verifyModelVisibleSkills({ command, env: baseEnv, runCommand, log, requiredSkills: requirements.skills, requirements });
     return { required: true, plugins, skills: requirements.skills, codexHome: null, baseCodexHome };
   }
 
@@ -404,32 +499,61 @@ async function provisionCodexCapabilities({ owner, repo, issueNumber, projectDir
   await prepareScopedCodexHome({ baseCodexHome, codexHome });
   const scopedEnv = { ...process.env, CODEX_HOME: codexHome, HIVE_MIND_PARENT_CODEX_HOME: baseCodexHome };
 
-  const scopedCatalogResult = await runCommand({ command, args: ['plugin', 'list', '--json'], env: scopedEnv });
-  const scopedCatalog = parseJsonCommand(scopedCatalogResult, 'Repository-scoped Codex plugin discovery');
-  const installed = new Set((scopedCatalog.installed || []).filter(plugin => plugin.installed && plugin.enabled).map(plugin => normalizePluginSelector(plugin.pluginId)));
-
-  for (const plugin of plugins) {
-    if (installed.has(plugin)) continue;
-    const installResult = await runCommand({ command, args: ['plugin', 'add', plugin, '--json'], env: scopedEnv });
-    parseJsonCommand(installResult, `Installing required Codex plugin ${plugin}`);
-    await log(`   ✅ Provisioned ${plugin} in repository-scoped Codex state`);
+  // Issue #2088: install *and repair*. Enablement recorded in the scoped
+  // `config.toml` survives a container restart while the payload under
+  // `plugins/cache` may not, and `codex plugin list` cannot tell those states
+  // apart — so the payload itself is the thing that gets checked and rebuilt.
+  const repair = await repairScopedPluginPayloads({ command, env: scopedEnv, runCommand, log, codexHome, baseCodexHome, plugins, providers });
+  for (const entry of repair.report) {
+    if (entry.healthy) await log(`   ✅ Provisioned ${entry.pluginId} in repository-scoped Codex state`);
   }
 
   const verifyResult = await runCommand({ command, args: ['plugin', 'list', '--json'], env: scopedEnv });
   const verifiedCatalog = parseJsonCommand(verifyResult, 'Codex capability verification');
   const verified = new Set((verifiedCatalog.installed || []).filter(plugin => plugin.installed && plugin.enabled).map(plugin => normalizePluginSelector(plugin.pluginId)));
   const unverified = plugins.filter(plugin => !verified.has(plugin));
-  if (unverified.length > 0) throw new CodexCapabilityPreflightError(`Codex capability installation did not verify successfully: ${unverified.join(', ')}`, { missing: unverified });
+  if (unverified.length > 0) {
+    const blockedSkills = repair.unhealthy.flatMap(entry => entry.missing);
+    throw new CodexCapabilityPreflightError(`Codex capability installation did not verify successfully: ${unverified.join(', ')}. ` + (blockedSkills.length > 0 ? `The required skills ${blockedSkills.join(', ')} are therefore unavailable. ` : '') + `Expected the plugin payload under CODEX_HOME/plugins/cache/<marketplace>/<plugin>/<version>/skills in ${codexHome}. ` + `Attempted repairs: ${repair.applied.join(', ') || 'none'}.`, {
+      missing: unverified,
+      failClosed: unverified.some(plugin => isExplicitRequirement(requirements, plugin)) || blockedSkills.some(skill => isExplicitRequirement(requirements, skill)),
+    });
+  }
 
   // Issue #2084: enablement is not exposure. The failing run reached this point
   // with `superpowers@openai-curated` reported as "installed, enabled" while
   // the model saw zero `superpowers:*` skills, so the run proceeded and then
   // stalled on the repository's mandatory preflight. Confirm the requirement
   // against the catalog the model actually receives.
-  await verifyModelVisibleSkills({ command, env: scopedEnv, runCommand, log, requiredSkills: requirements.skills });
+  let visibility = await checkModelVisibleSkills({ command, env: scopedEnv, runCommand, log, requiredSkills: requirements.skills });
+  if (visibility.status === 'missing') {
+    // The payload looks materialized but the prompt disagrees: rebuild it from
+    // scratch and re-probe before deciding (issue #2088).
+    await log(`   🛠️  Model cannot see ${visibility.missing.join(', ')}; forcing a repository-scoped plugin payload rebuild`);
+    const forced = await repairScopedPluginPayloads({ command, env: scopedEnv, runCommand, log, codexHome, baseCodexHome, plugins, providers, strategies: PLUGIN_PAYLOAD_REPAIRS.slice(1), force: true });
+    repair.applied.push(...forced.applied);
+    visibility = await checkModelVisibleSkills({ command, env: scopedEnv, runCommand, log, requiredSkills: requirements.skills });
+  }
+  if (visibility.status === 'missing') throw skillVisibilityError({ missing: visibility.missing, visible: visibility.visible, requirements, repairs: repair.applied });
+  if (visibility.status === 'unknown' && repair.unhealthy.length > 0) {
+    // Without the probe the materialized payload is the only evidence there is.
+    const missing = repair.unhealthy.flatMap(entry => (entry.missing.length > 0 ? entry.missing : [entry.pluginId]));
+    throw new CodexCapabilityPreflightError(`Repository-scoped Codex plugin payload could not be materialized for: ${missing.join(', ')}. ` + `Expected skills under CODEX_HOME/plugins/cache/<marketplace>/<plugin>/<version>/skills in ${codexHome}. ` + `Attempted repairs: ${repair.applied.join(', ') || 'none'}.`, { missing, failClosed: missing.some(capability => isExplicitRequirement(requirements, capability)) });
+  }
+  if (visibility.status === 'satisfied' && requirements.skills.length > 0) await log(`   ✅ Verified ${requirements.skills.length} required skill(s) are visible to the model`);
 
   await log(`   Codex capability state: ${codexHome}`, { verbose: true });
-  return { required: true, plugins, skills: requirements.skills, codexHome, baseCodexHome };
+  return { required: true, plugins, skills: requirements.skills, codexHome, baseCodexHome, repairs: repair.applied };
 }
 
-export default { applyCodexCapabilityEnv, detectRequiredCodexCapabilities, isCapabilityName, runCodexCapabilityPreflight };
+export default {
+  applyCodexCapabilityEnv,
+  buildPluginCachePath,
+  detectRequiredCodexCapabilities,
+  isCapabilityName,
+  isExplicitRequirement,
+  readMaterializedPluginSkills,
+  repairScopedPluginPayloads,
+  resolveRequiredCapabilities,
+  runCodexCapabilityPreflight,
+};

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