@link-assistant/hive-mind 2.8.6 → 2.8.8

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @link-assistant/hive-mind
 
+## 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
+
+- f8abac0: fix(telegram): apply operator `TELEGRAM_SOLVE_OVERRIDES` to the `/solve` started by `/fix` (#2085)
+
+  `/fix --ci-cd` genuinely spawns the real `solve.mjs`, but the Telegram bot's
+  operator solve overrides (e.g. `--attach-logs`) were only merged into `/solve`
+  and `/hive` — never `/fix`. As a result the solve launched by `/fix` ran
+  without the operator's defaults. The `mergeArgsWithOverrides` helper is now
+  extracted into a shared `src/args-overrides.lib.mjs` module and the `/fix`
+  handler applies `solveOverrides` (including an optional `--isolation` override)
+  exactly like `/solve` does, restoring the missing defaults.
+
 ## 2.8.6
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.8.6",
+  "version": "2.8.8",
   "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/args-overrides.lib.mjs

@@ -0,0 +1,74 @@
+/**
+ * Shared CLI-argument override merging (issue #2085).
+ *
+ * The Telegram bot lets operators configure "override" options that are always
+ * applied to a command regardless of what the requester typed — e.g.
+ * `TELEGRAM_SOLVE_OVERRIDES="(\n  --attach-logs\n  --auto-continue\n)"`. These
+ * overrides encode the operator's defaults for `/solve`.
+ *
+ * `mergeArgsWithOverrides` used to live inside `telegram-bot.mjs`, where only
+ * the `/solve` and `/hive` handlers could reach it. `/fix` hands its generated
+ * issue off to `/solve`, so it must apply the very same solve overrides —
+ * otherwise the solve started by `/fix` silently runs without the operator's
+ * defaults (issue #2085: "`--attach-logs` were not applied"). Extracting the
+ * helper here lets `telegram-fix-command.lib.mjs` reuse the exact same merge
+ * semantics without importing the bot entry point (which would be circular).
+ */
+
+/**
+ * Merge operator override options into a user-supplied argument list.
+ *
+ * Override flags win: any user flag that also appears in `overrides` (together
+ * with its value, if any) is dropped, then every override is appended. Boolean
+ * flags and `--flag value` pairs are both handled. The relative order of the
+ * surviving user args (including positionals like the issue/repository URL) is
+ * preserved, and the overrides are appended at the end so they take precedence
+ * in last-wins CLI parsers.
+ *
+ * @param {string[]} userArgs - Arguments the requester supplied.
+ * @param {string[]} overrides - Operator override options (already tokenized).
+ * @returns {string[]} The merged argument list.
+ */
+export function mergeArgsWithOverrides(userArgs, overrides) {
+  if (!overrides || overrides.length === 0) {
+    return Array.isArray(userArgs) ? userArgs : [];
+  }
+  const safeUserArgs = Array.isArray(userArgs) ? userArgs : [];
+
+  // Parse overrides to identify flags and their values
+  const overrideFlags = new Map(); // Map of flag -> value (or null for boolean flags)
+
+  for (let i = 0; i < overrides.length; i++) {
+    const arg = overrides[i];
+    if (arg.startsWith('--')) {
+      // Check if next item is a value (doesn't start with --)
+      if (i + 1 < overrides.length && !overrides[i + 1].startsWith('--')) {
+        overrideFlags.set(arg, overrides[i + 1]);
+        i++; // Skip the value in next iteration
+      } else {
+        overrideFlags.set(arg, null); // Boolean flag
+      }
+    }
+  }
+
+  // Filter user args to remove any that conflict with overrides
+  const filteredArgs = [];
+  for (let i = 0; i < safeUserArgs.length; i++) {
+    const arg = safeUserArgs[i];
+    if (arg.startsWith('--')) {
+      // If this flag exists in overrides, skip it and its value
+      if (overrideFlags.has(arg)) {
+        // Skip the flag
+        // Also skip next arg if it's a value (doesn't start with --)
+        if (i + 1 < safeUserArgs.length && !safeUserArgs[i + 1].startsWith('--')) {
+          i++; // Skip the value too
+        }
+        continue;
+      }
+    }
+    filteredArgs.push(arg);
+  }
+
+  // Merge: filtered user args + overrides
+  return [...filteredArgs, ...overrides];
+}

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/telegram-bot.mjs

@@ -29,6 +29,7 @@ const { createYargsConfig: createHiveYargsConfig } = await import('./hive.config
 const { enhanceUnknownArgumentError } = await import('./option-suggestions.lib.mjs');
 const { validateBranchInArgs } = await import('./solve.branch.lib.mjs');
 const { extractIsolationFromArgs, isValidPerCommandIsolation } = await import('./telegram-isolation.lib.mjs');
+const { mergeArgsWithOverrides } = await import('./args-overrides.lib.mjs'); // issue #2085
 
 const config = createTelegramYargsConfig(yargs(hideBin(process.argv))).parse();
 
@@ -367,49 +368,6 @@ function validateModelInArgs(args, tool = 'claude') {
   return null;
 }
 
-function mergeArgsWithOverrides(userArgs, overrides) {
-  if (!overrides || overrides.length === 0) {
-    return userArgs;
-  }
-
-  // Parse overrides to identify flags and their values
-  const overrideFlags = new Map(); // Map of flag -> value (or null for boolean flags)
-
-  for (let i = 0; i < overrides.length; i++) {
-    const arg = overrides[i];
-    if (arg.startsWith('--')) {
-      // Check if next item is a value (doesn't start with --)
-      if (i + 1 < overrides.length && !overrides[i + 1].startsWith('--')) {
-        overrideFlags.set(arg, overrides[i + 1]);
-        i++; // Skip the value in next iteration
-      } else {
-        overrideFlags.set(arg, null); // Boolean flag
-      }
-    }
-  }
-
-  // Filter user args to remove any that conflict with overrides
-  const filteredArgs = [];
-  for (let i = 0; i < userArgs.length; i++) {
-    const arg = userArgs[i];
-    if (arg.startsWith('--')) {
-      // If this flag exists in overrides, skip it and its value
-      if (overrideFlags.has(arg)) {
-        // Skip the flag
-        // Also skip next arg if it's a value (doesn't start with --)
-        if (i + 1 < userArgs.length && !userArgs[i + 1].startsWith('--')) {
-          i++; // Skip the value too
-        }
-        continue;
-      }
-    }
-    filteredArgs.push(arg);
-  }
-
-  // Merge: filtered user args + overrides
-  return [...filteredArgs, ...overrides];
-}
-
 // Inject --language LOCALE into spawn args if no language flag is already present.
 // Issue #378: telegram bot resolves the user's effective locale and propagates
 // it to spawned solve/hive sessions so the AI tool replies in the same language.
@@ -595,7 +553,7 @@ registerSubscribeCommands(bot, sharedCommandOpts);
 const { registerTaskCommands } = await import('./telegram-task-command.lib.mjs');
 const { handleTaskCommand, TASK_COMMAND_NAMES } = registerTaskCommands(bot, { ...sharedCommandOpts, taskEnabled, safeReply, executeAndUpdateMessage, resolveLocale: resolveLocaleFromTelegramCtx });
 const { registerFixCommand } = await import('./telegram-fix-command.lib.mjs');
-const { handleFixCommand, FIX_COMMAND_NAMES } = registerFixCommand(bot, { ...sharedCommandOpts, fixEnabled, safeReply, executeAndUpdateMessage, resolveLocale: resolveLocaleFromTelegramCtx });
+const { handleFixCommand, FIX_COMMAND_NAMES } = registerFixCommand(bot, { ...sharedCommandOpts, fixEnabled, safeReply, executeAndUpdateMessage, resolveLocale: resolveLocaleFromTelegramCtx, solveOverrides });
 const { registerAuthCommand } = await import('./telegram-auth-command.lib.mjs');
 const { handleAuthCommand } = registerAuthCommand(bot, { ...sharedCommandOpts, allowedChats, authEnabled, safeReply });
 

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

@@ -12,6 +12,7 @@ import { validateModelName } from './models/index.mjs';
 import { parseFixRepository } from './fix.ci-cd.lib.mjs';
 import { escapeMarkdown } from './telegram-markdown.lib.mjs';
 import { extractIsolationFromArgs, isValidPerCommandIsolation } from './telegram-isolation.lib.mjs';
+import { mergeArgsWithOverrides } from './args-overrides.lib.mjs';
 import { moveArgumentToFront, parseCommandArgs } from './telegram-solve-command.lib.mjs';
 import { formatStartingWorkSessionMessage } from './work-session-formatting.lib.mjs';
 
@@ -87,7 +88,7 @@ function injectLanguageIfMissing(args, locale) {
 }
 
 export function registerFixCommand(bot, options) {
-  const { VERBOSE, fixEnabled, addBreadcrumb, isOldMessage, isForwardedOrReply, isGroupChat, isTopicAuthorized, buildAuthErrorMessage, isChatStopped, getStoppedChatRejectMessage, safeReply, executeAndUpdateMessage, resolveLocale = null } = options;
+  const { VERBOSE, fixEnabled, addBreadcrumb, isOldMessage, isForwardedOrReply, isGroupChat, isTopicAuthorized, buildAuthErrorMessage, isChatStopped, getStoppedChatRejectMessage, safeReply, executeAndUpdateMessage, resolveLocale = null, solveOverrides = [] } = options;
 
   async function handleFixCommand(ctx) {
     const commandDisplay = '/fix';
@@ -137,7 +138,22 @@ export function registerFixCommand(bot, options) {
       return;
     }
 
-    const modelError = validateFixModel(filteredArgs);
+    // Issue #2085: /fix hands the generated issue off to /solve, so it must
+    // apply the operator's solve overrides (TELEGRAM_SOLVE_OVERRIDES) exactly
+    // like the /solve handler does — otherwise the solve started by /fix runs
+    // without the operator's defaults (e.g. --attach-logs). The overrides are
+    // forwarded to /solve because /fix passes every option it does not consume
+    // through to solve.mjs. An --isolation override applies to the /fix work
+    // session itself (which contains the nested /solve), mirroring /solve.
+    const { backend: overrideIsolation, filteredArgs: solveOverridesWithoutIsolation } = extractIsolationFromArgs(solveOverrides);
+    if (overrideIsolation && !isValidPerCommandIsolation(overrideIsolation)) {
+      await safeReply(ctx, `❌ Invalid --isolation value '${escapeMarkdown(overrideIsolation)}' in solve overrides. Must be: screen, tmux, or docker`, { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+    const effectiveIsolation = overrideIsolation || perCommandIsolation;
+    const mergedArgs = mergeArgsWithOverrides(filteredArgs, solveOverridesWithoutIsolation);
+
+    const modelError = validateFixModel(mergedArgs);
     if (modelError) {
       await safeReply(ctx, `❌ ${escapeMarkdown(modelError)}`, { reply_to_message_id: ctx.message.message_id });
       return;
@@ -147,12 +163,13 @@ export function registerFixCommand(bot, options) {
     const userOptionsRaw = built.args.slice(1).join(' ');
     let infoBlock = `Requested by: ${requester}\nRepository: ${escapeMarkdown(built.repository.url)}`;
     if (userOptionsRaw) infoBlock += `\n\n🛠 Options: ${escapeMarkdown(userOptionsRaw)}`;
+    if (solveOverrides.length > 0) infoBlock += `\n\n🔒 Solve overrides: ${escapeMarkdown(solveOverrides.join(' '))}`;
 
     const fixUrlContext = { owner: built.repository.owner, repo: built.repository.repo, normalized: built.repository.url };
     const startingMessage = await safeReply(ctx, formatStartingWorkSessionMessage({ infoBlock }), { reply_to_message_id: ctx.message.message_id });
     const fixLocale = resolveLocale ? resolveLocale(ctx) : null;
-    const argsForExec = injectLanguageIfMissing(filteredArgs, fixLocale);
-    await executeAndUpdateMessage(ctx, startingMessage, 'fix', argsForExec, infoBlock, perCommandIsolation || null, getFixToolFromArgs(argsForExec), fixUrlContext);
+    const argsForExec = injectLanguageIfMissing(mergedArgs, fixLocale);
+    await executeAndUpdateMessage(ctx, startingMessage, 'fix', argsForExec, infoBlock, effectiveIsolation || null, getFixToolFromArgs(argsForExec), fixUrlContext);
   }
 
   bot.command(