@link-assistant/hive-mind 2.1.11 → 2.2.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 2.2.1
+
+### Patch Changes
+
+- e86a40e: Add a `--development-log` solve option that prompts agents to collect issue data, then preserves and commits resumable tool sessions under per-session UUID directories.
+
+## 2.2.0
+
+### Minor Changes
+
+- d3b7c97: Default `--tool codex` to `gpt-5.6-sol` and make the `--think` levels map predictably to Codex reasoning efforts (`off`→`none`, `low`/`medium`/`high`/`xhigh`/`ultra`/`max` as an identity mapping). GPT-5.6 Sol's multi-agent `ultra` mode is always paired with a `rollout_token_budget` cap (default `500000`, overridable via `--rollout-token-budget`), and budget-derived effort stays capped at `xhigh`. Align `--tool claude` by adding the matching `ultra` level (equivalent to `ultracode`). By default both tools run the model as-is with no thinking level enforced.
+
 ## 2.1.11
 
 ### Patch Changes

package/README.hi.md

@@ -39,7 +39,7 @@ Hive Mind एक **सामान्यवादी AI** (मिनी-AGI) ह
 | सदस्यता                                                          | `--tool` के साथ     | डिफ़ॉल्ट मॉडल | किसके लिए बेहतर है                                |
 | ---------------------------------------------------------------- | ------------------- | ------------- | ------------------------------------------------- |
 | **Anthropic Claude MAX** (~$200/माह, अक्सर 50% छूट = $400 मूल्य) | `claude` (डिफ़ॉल्ट) | Sonnet/Haiku  | उच्चतम रचनात्मकता, मजबूत सामान्य कोड रीजनिंग      |
-| **OpenAI ChatGPT Pro** ($200/माह, Codex शामिल)                   | `codex`             | `gpt-5.5`     | भरोसेमंद deterministic refactors और तेज iteration |
+| **OpenAI ChatGPT Pro** ($200/माह, Codex शामिल)                   | `codex`             | `gpt-5.6-sol` | भरोसेमंद deterministic refactors और तेज iteration |
 
 दोनों टूल एक ही hive में साथ उपयोग किए जा सकते हैं। Worker अलग-अलग टूल समानांतर चला सकते हैं, और `/codex` या `/solve --tool codex` कार्यों को ChatGPT Pro पर भेजता है जबकि डिफ़ॉल्ट Claude MAX पर जाता है। किसी एक को चुनना आवश्यक नहीं है: किसी भी एक सदस्यता से संचालन संभव है, और दोनों का उपयोग per-tool/model concurrency mode (#1474) खोलता है।
 

package/README.md

@@ -39,7 +39,7 @@ Hive Mind is a **generalist AI** (mini-AGI) capable of working on a wide range o
 | Subscription                                                       | Pairs with `--tool` | Default model | Best for                                                |
 | ------------------------------------------------------------------ | ------------------- | ------------- | ------------------------------------------------------- |
 | **Anthropic Claude MAX** (~$200/month, often 50% off = $400 value) | `claude` (default)  | Sonnet/Haiku  | Highest creativity, strongest general code reasoning    |
-| **OpenAI ChatGPT Pro** ($200/month, includes Codex)                | `codex`             | `gpt-5.5`     | Strong deterministic refactors and fast iteration loops |
+| **OpenAI ChatGPT Pro** ($200/month, includes Codex)                | `codex`             | `gpt-5.6-sol` | Strong deterministic refactors and fast iteration loops |
 
 Both tools can be combined in the same hive. Workers can run different tools in parallel, and `/codex` or `/solve --tool codex` routes tasks to ChatGPT Pro while the default routes to Claude MAX. There is no requirement to pick one: either single subscription is enough to operate, and using both unlocks per-tool/model concurrency mode (#1474).
 
@@ -507,15 +507,15 @@ Free Models via Kilo Gateway (with --tool agent):
 
 Current tool defaults in Hive Mind:
 
-| Tool       | Default model                                               | Default reasoning behavior                                                               |
-| ---------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
-| `claude`   | `sonnet`                                                    | No extra thinking is requested unless you pass `--think` or `--thinking-budget`          |
-| `codex`    | `gpt-5.5` preferred, with runtime fallback to local catalog | Codex runs with `reasoning_effort=none` unless you pass `--think` or `--thinking-budget` |
-| `opencode` | `grok-code-fast-1`                                          | No extra thinking prompt is added for the default model                                  |
-| `agent`    | `nemotron-3-super-free`                                     | No extra thinking prompt is added for the default model                                  |
-| `gemini`   | `flash`                                                     | No extra thinking prompt is added for the default model                                  |
-| `qwen`     | `qwen3-coder-plus`                                          | No extra thinking prompt is added for the default model                                  |
-| `gemini`   | `gemini-2.5-flash`                                          | No extra thinking prompt is added for the default model                                  |
+| Tool       | Default model                                                               | Default reasoning behavior                                                               |
+| ---------- | --------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
+| `claude`   | `sonnet`                                                                    | No extra thinking is requested unless you pass `--think` or `--thinking-budget`          |
+| `codex`    | `gpt-5.6-sol` preferred, with runtime fallback to local catalog (`gpt-5.5`) | Codex runs with `reasoning_effort=none` unless you pass `--think` or `--thinking-budget` |
+| `opencode` | `grok-code-fast-1`                                                          | No extra thinking prompt is added for the default model                                  |
+| `agent`    | `nemotron-3-super-free`                                                     | No extra thinking prompt is added for the default model                                  |
+| `gemini`   | `flash`                                                                     | No extra thinking prompt is added for the default model                                  |
+| `qwen`     | `qwen3-coder-plus`                                                          | No extra thinking prompt is added for the default model                                  |
+| `gemini`   | `gemini-2.5-flash`                                                          | No extra thinking prompt is added for the default model                                  |
 
 See [docs/CONFIGURATION.md](./docs/CONFIGURATION.md) for the full per-tool defaults and reasoning mappings.
 

package/README.ru.md

@@ -39,7 +39,7 @@ Hive Mind — это **универсальный ИИ** (мини-AGI), спо
 | Подписка                                                          | Используется с `--tool` | Модель по умолчанию | Лучше всего подходит для                                   |
 | ----------------------------------------------------------------- | ----------------------- | ------------------- | ---------------------------------------------------------- |
 | **Anthropic Claude MAX** (~$200 в месяц, часто скидка 50% = $400) | `claude` (по умолчанию) | Sonnet/Haiku        | Максимальная креативность и сильное общее кодовое мышление |
-| **OpenAI ChatGPT Pro** ($200 в месяц, включает Codex)             | `codex`                 | `gpt-5.5`           | Надёжные детерминированные рефакторинги и быстрые итерации |
+| **OpenAI ChatGPT Pro** ($200 в месяц, включает Codex)             | `codex`                 | `gpt-5.6-sol`       | Надёжные детерминированные рефакторинги и быстрые итерации |
 
 Оба инструмента можно сочетать в одном hive. Воркеры могут параллельно запускать разные инструменты, а `/codex` или `/solve --tool codex` направляет задачи в ChatGPT Pro, тогда как маршрут по умолчанию идёт в Claude MAX. Выбирать только один вариант не требуется: любой одной подписки достаточно для работы, а использование обеих открывает режим параллелизма по инструментам/моделям (#1474).
 

package/README.zh.md

@@ -36,10 +36,10 @@ Hive Mind 是一款**通用 AI**（迷你 AGI），能够处理广泛的任务
 
 **费用**：Hive Mind 支持两种 $200/月订阅作为功能完整、近乎“无限”的选项：
 
-| 订阅                                                             | 搭配 `--tool`    | 默认模型     | 最适合场景                   |
-| ---------------------------------------------------------------- | ---------------- | ------------ | ---------------------------- |
-| **Anthropic Claude MAX**（约 $200/月，常有五折优惠 = 价值 $400） | `claude`（默认） | Sonnet/Haiku | 最高创造力、最强通用代码推理 |
-| **OpenAI ChatGPT Pro**（$200/月，包含 Codex）                    | `codex`          | `gpt-5.5`    | 稳定确定性的重构和快速迭代   |
+| 订阅                                                             | 搭配 `--tool`    | 默认模型      | 最适合场景                   |
+| ---------------------------------------------------------------- | ---------------- | ------------- | ---------------------------- |
+| **Anthropic Claude MAX**（约 $200/月，常有五折优惠 = 价值 $400） | `claude`（默认） | Sonnet/Haiku  | 最高创造力、最强通用代码推理 |
+| **OpenAI ChatGPT Pro**（$200/月，包含 Codex）                    | `codex`          | `gpt-5.6-sol` | 稳定确定性的重构和快速迭代   |
 
 两个工具可以在同一个 hive 中组合使用。Worker 可以并行运行不同工具，`/codex` 或 `/solve --tool codex` 会将任务路由到 ChatGPT Pro，而默认路由到 Claude MAX。无需二选一：任意单一订阅都足以运行，同时使用两者可解锁按工具/模型划分的并发模式（#1474）。
 

package/package.json

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

package/src/agent-commander.lib.mjs

@@ -62,8 +62,13 @@ const buildClaudeToolOptions = (argv = {}) => {
 
 const buildCodexToolOptions = (argv = {}) => {
   const options = {};
-  const { reasoningEffort } = resolveCodexReasoningEffort(argv);
-  appendExtraArgs(options, ['-c', `model_reasoning_effort=${reasoningEffort}`, '-c', 'model_reasoning_summary=auto']);
+  const { reasoningEffort, rolloutTokenBudget } = resolveCodexReasoningEffort(argv);
+  const reasoningArgs = ['-c', `model_reasoning_effort=${reasoningEffort}`, '-c', 'model_reasoning_summary=auto'];
+  // Issue #2027: pair GPT-5.6 Sol's multi-agent `ultra` effort with a rollout token budget cap.
+  if (rolloutTokenBudget) {
+    reasoningArgs.push('-c', `rollout_token_budget=${rolloutTokenBudget}`);
+  }
+  appendExtraArgs(options, reasoningArgs);
 
   appendExtraArgs(options, buildCodexDisable1mContextConfigArgs(!!argv.disable1mContext));
   try {

package/src/agent.prompts.lib.mjs

@@ -8,6 +8,7 @@ import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 import { buildRequestedBaseBranchDirective } from './solve-option-contract.prompts.lib.mjs';
+import { buildDevelopmentLogPrompt } from './development-log.lib.mjs';
 
 /**
  * Build the user prompt for Agent
@@ -66,6 +67,11 @@ export const buildUserPrompt = params => {
     promptLines.push('');
   }
 
+  const developmentLogPrompt = buildDevelopmentLogPrompt({ argv, issueNumber, prNumber }).trim();
+  if (developmentLogPrompt) {
+    promptLines.push(developmentLogPrompt, '');
+  }
+
   const thinkingPromptInstruction = getThinkingPromptInstruction({ tool: 'agent', argv });
   if (thinkingPromptInstruction) {
     promptLines.push(thinkingPromptInstruction);

package/src/claude.prompts.lib.mjs

@@ -10,6 +10,7 @@ import { primaryModelNames } from './models/index.mjs';
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 import { buildRequestedBaseBranchDirective } from './solve-option-contract.prompts.lib.mjs';
+import { buildDevelopmentLogPrompt } from './development-log.lib.mjs';
 
 /**
  * Build the user prompt for Claude
@@ -79,6 +80,11 @@ export const buildUserPrompt = params => {
     promptLines.push('');
   }
 
+  const developmentLogPrompt = buildDevelopmentLogPrompt({ argv, issueNumber, prNumber }).trim();
+  if (developmentLogPrompt) {
+    promptLines.push(developmentLogPrompt, '');
+  }
+
   const thinkingPromptInstruction = getThinkingPromptInstruction({ tool: 'claude', argv, claudeVersion });
   if (thinkingPromptInstruction) {
     promptLines.push(thinkingPromptInstruction);

package/src/codex.lib.mjs

@@ -804,7 +804,7 @@ export const executeCodexCommand = async params => {
 
     let execCommand;
     const mappedModel = mapModelToId(argv.model);
-    const { reasoningEffort, source: reasoningEffortSource } = resolveCodexReasoningEffort(argv);
+    const { reasoningEffort, source: reasoningEffortSource, rolloutTokenBudget } = resolveCodexReasoningEffort(argv);
     const isResumeMode = !!argv.resume;
     const codexEnv = getCodexExecEnv(argv.verbose);
 
@@ -839,7 +839,10 @@ export const executeCodexCommand = async params => {
     for (const arg of codexPlaywrightMcpDisableConfigArgs) {
       codexArgs += ` ${shellQuote(arg)}`;
     }
-    codexArgs += ` --json --skip-git-repo-check -o ${shellQuote(lastMessageFile)} -c ${shellQuote(`model_reasoning_effort=${reasoningEffort}`)} -c ${shellQuote('model_reasoning_summary=auto')} --dangerously-bypass-approvals-and-sandbox`;
+    codexArgs += ` --json --skip-git-repo-check -o ${shellQuote(lastMessageFile)} -c ${shellQuote(`model_reasoning_effort=${reasoningEffort}`)} -c ${shellQuote('model_reasoning_summary=auto')}`;
+    // Issue #2027: pair GPT-5.6 Sol's multi-agent `ultra` effort with a rollout token budget cap so it stays predictable and does not run away on cost.
+    if (rolloutTokenBudget) codexArgs += ` -c ${shellQuote(`rollout_token_budget=${rolloutTokenBudget}`)}`;
+    codexArgs += ' --dangerously-bypass-approvals-and-sandbox';
 
     // Issue #1706: Append --disable-1m-context and --sub-session-size as Codex -c overrides.
     let parsedSubSessionSize;

package/src/codex.options.lib.mjs

@@ -4,13 +4,34 @@ import { codexModels } from './models/index.mjs';
 
 export const mapModelToId = model => codexModels[model] || model;
 
+// Issue #2027: Map the shared hive-mind --think levels to Codex `model_reasoning_effort`
+// values. GPT-5.6 Sol (the default Codex model) keeps the full ladder inherited from the
+// GPT-5.5/GPT-5.4 generation — low/medium/high/xhigh — and adds `max` *above* xhigh for the
+// deepest single-agent reasoning, plus a multi-agent `ultra` mode. Because every hive level
+// has a same-named Codex reasoning effort, the mapping is a predictable identity: `xhigh`
+// stays `xhigh` (natively supported per `codex debug models`), `ultra` selects GPT-5.6's
+// multi-agent ultra mode (the counterpart of Claude's "ultracode"), and `max` selects the
+// deepest single-agent effort. `off` disables reasoning (`none`). See docs/case-studies/issue-2027.
 const THINK_LEVEL_TO_CODEX_REASONING = {
   off: 'none',
   low: 'low',
   medium: 'medium',
   high: 'high',
   xhigh: 'xhigh',
-  max: 'xhigh',
+  ultra: 'ultra',
+  max: 'max',
+};
+
+// Issue #2027: GPT-5.6 Sol's multi-agent `ultra` mode spawns subagents and consumes far more
+// tokens per turn than single-agent reasoning. OpenAI's guidance is explicit: never use `ultra`
+// reasoning effort without a `rollout_token_budget` cap, or it can run away on cost. We pair
+// every `ultra` selection with this budget (their recommended default) so `--think ultra` stays
+// predictable. Override with `--rollout-token-budget`.
+export const CODEX_ULTRA_ROLLOUT_TOKEN_BUDGET = 500000;
+
+const resolveUltraRolloutTokenBudget = argv => {
+  const override = argv?.rolloutTokenBudget;
+  return Number.isFinite(override) && override > 0 ? override : CODEX_ULTRA_ROLLOUT_TOKEN_BUDGET;
 };
 
 export const resolveCodexReasoningEffort = argv => {
@@ -26,6 +47,10 @@ export const resolveCodexReasoningEffort = argv => {
     }
 
     const ratio = Math.min(1, thinkingBudget / maxBudget);
+    // Issue #2027: the budget-derived effort caps at `xhigh` — the deepest tier every Codex
+    // model (including the gpt-5.5 runtime fallback) supports. `max` is GPT-5.6-only and `ultra`
+    // needs a paired rollout token budget, so both require an explicit `--think max`/`--think ultra`
+    // to stay predictable rather than being reached implicitly through a token budget.
     const reasoningEffort = ratio <= 0.2 ? 'minimal' : ratio <= 0.4 ? 'low' : ratio <= 0.6 ? 'medium' : ratio <= 0.8 ? 'high' : 'xhigh';
 
     return {
@@ -35,10 +60,15 @@ export const resolveCodexReasoningEffort = argv => {
   }
 
   if (argv?.think && THINK_LEVEL_TO_CODEX_REASONING[argv.think]) {
-    return {
-      reasoningEffort: THINK_LEVEL_TO_CODEX_REASONING[argv.think],
+    const reasoningEffort = THINK_LEVEL_TO_CODEX_REASONING[argv.think];
+    const result = {
+      reasoningEffort,
       source: `--think ${argv.think}`,
     };
+    if (reasoningEffort === 'ultra') {
+      result.rolloutTokenBudget = resolveUltraRolloutTokenBudget(argv);
+    }
+    return result;
   }
 
   return {
@@ -50,4 +80,5 @@ export const resolveCodexReasoningEffort = argv => {
 export default {
   mapModelToId,
   resolveCodexReasoningEffort,
+  CODEX_ULTRA_ROLLOUT_TOKEN_BUDGET,
 };

package/src/codex.prompts.lib.mjs

@@ -9,6 +9,7 @@ import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 import { buildRequestedBaseBranchDirective } from './solve-option-contract.prompts.lib.mjs';
+import { buildDevelopmentLogPrompt } from './development-log.lib.mjs';
 
 /**
  * Build the user prompt for Codex
@@ -67,6 +68,11 @@ export const buildUserPrompt = params => {
     promptLines.push('');
   }
 
+  const developmentLogPrompt = buildDevelopmentLogPrompt({ argv, issueNumber, prNumber }).trim();
+  if (developmentLogPrompt) {
+    promptLines.push(developmentLogPrompt, '');
+  }
+
   const thinkingPromptInstruction = getThinkingPromptInstruction({ tool: 'codex', argv });
   if (thinkingPromptInstruction) {
     promptLines.push(thinkingPromptInstruction);

package/src/config.lib.mjs

@@ -397,6 +397,7 @@ export const getThinkingLevelToTokens = (maxBudget = DEFAULT_MAX_THINKING_BUDGET
   medium: Math.floor(maxBudget / 2), // ~16000 for default 31999
   high: Math.floor((maxBudget * 3) / 4), // ~24000 for default 31999
   xhigh: maxBudget, // same as max when represented as MAX_THINKING_TOKENS
+  ultra: maxBudget, // Issue #2027: ultra is max-class in token terms for Claude
   max: maxBudget, // 31999 by default
 });
 
@@ -482,10 +483,13 @@ export const OPUS_46_EFFORT_LEVELS = ['low', 'medium', 'high', 'max'];
 export const OPUS_47_EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
 
 /**
- * Convert thinking level to effort level (Issue #1238, Issue #1620)
+ * Convert thinking level to effort level (Issue #1238, Issue #1620, Issue #2027)
  * Models with max support keep max as max. Opus 4.7 keeps xhigh as xhigh.
  * Models with effort but without max support use high for max/xhigh.
- * @param {string|undefined} thinkLevel - The thinking level (off/low/medium/high/xhigh/max)
+ * `ultra` (Issue #2027) requests Claude "ultracode"-class reasoning; Claude Code has no
+ * distinct `ultra`/`ultracode` effort value, so it clamps to the highest supported effort
+ * (max, else xhigh, else high).
+ * @param {string|undefined} thinkLevel - The thinking level (off/low/medium/high/xhigh/ultra/max)
  * @param {Object} [options] - Options
  * @param {boolean} [options.isOpus47] - Backward-compatible shorthand for supportsXHigh
  * @param {boolean} [options.supportsXHigh] - Whether the model supports xhigh effort
@@ -509,6 +513,8 @@ export const thinkLevelToEffortLevel = (thinkLevel, options = {}) => {
       return 'high';
     case 'xhigh':
       return supportsXHigh ? 'xhigh' : supportsMax ? 'max' : 'high';
+    case 'ultra':
+      return supportsMax ? 'max' : supportsXHigh ? 'xhigh' : 'high';
     case 'max':
       return supportsMax ? 'max' : 'high';
     default:

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

@@ -0,0 +1,11 @@
+/**
+ * Build a once-only finalizer so both the normal and error completion paths can
+ * preserve a development log without creating duplicate commits.
+ */
+export const createDevelopmentLogFinalizer = ({ collect, getParams }) => {
+  let resultPromise = null;
+  return () => {
+    if (!resultPromise) resultPromise = Promise.resolve().then(() => collect(getParams()));
+    return resultPromise;
+  };
+};

package/src/development-log.lib.mjs

@@ -0,0 +1,297 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+const sanitizePathSegment = (value, fallback) => {
+  const raw = value === null || value === undefined || value === '' ? fallback : String(value);
+  const sanitized = raw.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+  return sanitized || fallback;
+};
+
+const stripDotSlash = value => value.replace(/^\.\//, '');
+const toPosixPath = value => value.split(path.sep).join('/');
+const addDotSlash = value => (value.startsWith('./') ? value : `./${value}`);
+
+const safeFileName = value => sanitizePathSegment(value, 'session');
+
+export const buildDevelopmentLogDirectory = ({ issueNumber, prNumber }) => {
+  const issueSegment = sanitizePathSegment(issueNumber, 'unknown');
+  const prSegment = sanitizePathSegment(prNumber, 'pending');
+  return `./dev/log/issues/${issueSegment}/pulls/${prSegment}`;
+};
+
+export const buildCaseStudyDirectory = ({ issueNumber }) => {
+  const issueSegment = sanitizePathSegment(issueNumber, 'unknown');
+  return `./docs/case-studies/issue-${issueSegment}`;
+};
+
+// Normalize a GitHub issue type (or label) into one of the buckets the
+// development-log prompt distinguishes. Bug issues get the stronger
+// "download all logs" wording; everything else (feature, task, or an
+// unspecified/unknown type) gets the universal data-collection wording.
+export const isBugIssueType = issueType => {
+  if (issueType === null || issueType === undefined) return false;
+  const normalized = String(issueType).trim().toLowerCase();
+  if (!normalized) return false;
+  return normalized === 'bug' || normalized === 'bugs' || normalized.includes('bug') || normalized === 'defect';
+};
+
+// True when the run requested the development log via --development-log
+// (yargs exposes both the camelCase and kebab-case keys).
+export const isDevelopmentLogEnabled = argv => argv?.developmentLog === true || argv?.['development-log'] === true;
+
+export const buildDevelopmentLogPrompt = ({ argv, issueNumber, prNumber, issueType }) => {
+  if (!(argv?.developmentLog || argv?.['development-log'])) return '';
+
+  const developmentLogDirectory = buildDevelopmentLogDirectory({ issueNumber, prNumber });
+  // Automatic support for issue types: when the issue type is "bug" the
+  // instruction asks to download all logs as well; for feature/task issues, or
+  // when no issue type is selected, the universal data-collection wording is used.
+  const resolvedIssueType = issueType ?? argv?.issueType ?? null;
+  const collectionInstruction = isBugIssueType(resolvedIssueType) ? `Download all logs and collect data related about the issue to this repository, make sure we compile that data into the ${developmentLogDirectory} folder.` : `Collect data related about the issue to this repository, make sure we compile that data into the ${developmentLogDirectory} folder.`;
+
+  return `\n${collectionInstruction}\n`;
+};
+
+// Fetch the GitHub issue type (e.g. "Bug", "Feature", "Task") for an issue.
+// Returns null when the type cannot be determined (no type selected, command
+// failure, or non-issue targets). Accepts an injectable command runner so the
+// behavior can be unit tested without hitting the network.
+export const fetchIssueType = async ({ owner, repo, issueNumber, $, log }) => {
+  if (!owner || !repo || !issueNumber || typeof $ !== 'function') return null;
+  try {
+    // eslint-disable-next-line gh-rate-limit/no-direct-gh-exec -- $ is the injected, rate-limit-safe runner (wrapDollarWithGhRetry) passed in by the caller.
+    const result = await $`gh issue view ${issueNumber} --repo ${owner}/${repo} --json issueType`;
+    if (result?.code && result.code !== 0) return null;
+    const stdout = result?.stdout?.toString?.() ?? String(result?.stdout ?? '');
+    if (!stdout.trim()) return null;
+    const parsed = JSON.parse(stdout);
+    const name = parsed?.issueType?.name;
+    return name ? String(name) : null;
+  } catch (error) {
+    await log?.(`ℹ️  Could not determine issue type: ${error.message}`, { verbose: true });
+    return null;
+  }
+};
+
+const fileExists = async filePath => {
+  try {
+    const stat = await fs.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+};
+
+const copyIfExists = async ({ sourcePath, destinationPath }) => {
+  if (!(await fileExists(sourcePath))) return false;
+  await fs.copyFile(sourcePath, destinationPath);
+  return true;
+};
+
+const getClaudeSessionFile = ({ repositoryPath, sessionId, homeDir }) => {
+  if (!repositoryPath || !sessionId || !homeDir) return null;
+  const projectDirName = repositoryPath.replace(/\//g, '-');
+  return path.join(homeDir, '.claude', 'projects', projectDirName, `${sessionId}.jsonl`);
+};
+
+// Codex CLI stores its transcript ("rollout") under
+// ~/.codex/sessions/YYYY/MM/DD/rollout-<timestamp>-<sessionId>.jsonl. The date
+// path and timestamp are not derivable from the sessionId, so locate the file
+// by recursively matching the sessionId suffix instead.
+const findCodexSessionFile = async ({ sessionId, homeDir }) => {
+  if (!sessionId || !homeDir) return null;
+  const sessionsRoot = path.join(homeDir, '.codex', 'sessions');
+  try {
+    const entries = await fs.readdir(sessionsRoot, { recursive: true });
+    const match = entries.find(entry => typeof entry === 'string' && entry.includes('rollout-') && entry.endsWith(`-${sessionId}.jsonl`));
+    return match ? path.join(sessionsRoot, match) : null;
+  } catch {
+    return null;
+  }
+};
+
+const copyKnownSessionFiles = async ({ repositoryPath, sessionRelativeDirectory, logFile, sessionId, tool, homeDir }) => {
+  if (!sessionId) return [];
+
+  const sessionDirectory = path.join(repositoryPath, sessionRelativeDirectory);
+  const candidates = [];
+  const logDirectory = logFile ? path.dirname(logFile) : null;
+
+  if (logDirectory) {
+    candidates.push({
+      sourcePath: path.join(logDirectory, `${sessionId}.log`),
+      destinationName: `${tool || 'tool'}-${sessionId}.log`,
+    });
+  }
+
+  if (tool === 'claude') {
+    const claudeSessionFile = getClaudeSessionFile({ repositoryPath, sessionId, homeDir });
+    if (claudeSessionFile) {
+      candidates.push({
+        sourcePath: claudeSessionFile,
+        destinationName: `claude-${sessionId}.jsonl`,
+      });
+    }
+  }
+
+  if (tool === 'codex') {
+    const codexSessionFile = await findCodexSessionFile({ sessionId, homeDir });
+    if (codexSessionFile) {
+      candidates.push({
+        sourcePath: codexSessionFile,
+        destinationName: `codex-${sessionId}.jsonl`,
+      });
+    }
+  }
+
+  const copied = [];
+  const seenSources = new Set();
+  for (const candidate of candidates) {
+    if (!candidate.sourcePath || seenSources.has(candidate.sourcePath)) continue;
+    seenSources.add(candidate.sourcePath);
+
+    const relativePath = `${sessionRelativeDirectory}/${safeFileName(candidate.destinationName)}`;
+    const copiedPath = path.join(sessionDirectory, safeFileName(candidate.destinationName));
+    if (await copyIfExists({ sourcePath: candidate.sourcePath, destinationPath: copiedPath })) {
+      copied.push(addDotSlash(toPosixPath(relativePath)));
+    }
+  }
+
+  return copied;
+};
+
+export const writeDevelopmentLogArtifacts = async ({ repositoryPath, logFile, issueNumber, prNumber, tool, sessionId, branchName, rawCommand, now = new Date(), homeDir = os.homedir() }) => {
+  if (!repositoryPath) {
+    throw new Error('repositoryPath is required to write development-log artifacts');
+  }
+
+  const developmentLogDirectory = buildDevelopmentLogDirectory({ issueNumber, prNumber });
+  const caseStudyDirectory = buildCaseStudyDirectory({ issueNumber });
+  const relativeDirectory = stripDotSlash(developmentLogDirectory);
+  const timestamp = now.toISOString().replace(/[:.]/g, '-');
+  const sessionDirectoryName = safeFileName(sessionId || `run-${timestamp}`);
+  const sessionRelativeDirectory = `${relativeDirectory}/sessions/${sessionDirectoryName}`;
+  const sessionDirectory = path.join(repositoryPath, sessionRelativeDirectory);
+
+  await fs.mkdir(sessionDirectory, { recursive: true });
+
+  let copiedLogRelativePath = null;
+  if (logFile) {
+    copiedLogRelativePath = `${sessionRelativeDirectory}/solve.log`;
+    await fs.copyFile(logFile, path.join(repositoryPath, copiedLogRelativePath));
+  }
+
+  const sessionFiles = await copyKnownSessionFiles({
+    repositoryPath,
+    sessionRelativeDirectory,
+    logFile,
+    sessionId,
+    tool,
+    homeDir,
+  });
+
+  const metadataRelativePath = `${sessionRelativeDirectory}/metadata.json`;
+  const metadata = {
+    schemaVersion: 2,
+    collectedAt: now.toISOString(),
+    issueNumber: issueNumber ?? null,
+    prNumber: prNumber ?? null,
+    branchName: branchName || null,
+    tool: tool || null,
+    sessionId: sessionId || null,
+    rawCommand: rawCommand || null,
+    developmentLogDirectory,
+    caseStudyDirectory,
+    artifacts: {
+      solveLog: copiedLogRelativePath ? addDotSlash(toPosixPath(copiedLogRelativePath)) : null,
+      sessionFiles,
+    },
+  };
+
+  await fs.writeFile(path.join(repositoryPath, metadataRelativePath), `${JSON.stringify(metadata, null, 2)}\n`, 'utf8');
+
+  return {
+    developmentLogDirectory,
+    caseStudyDirectory,
+    relativeDirectory,
+    sessionRelativeDirectory,
+    copiedLogRelativePath: copiedLogRelativePath ? toPosixPath(copiedLogRelativePath) : null,
+    metadataRelativePath: toPosixPath(metadataRelativePath),
+    sessionFiles,
+  };
+};
+
+const getCommandOutput = result => (result?.stderr?.toString?.() || result?.stdout?.toString?.() || '').trim();
+
+export const collectAndCommitDevelopmentLogArtifacts = async ({ enabled, repositoryPath, logFile, issueNumber, prNumber, tool, sessionId, branchName, rawCommand, $, log }) => {
+  if (!enabled) {
+    return { skipped: 'disabled' };
+  }
+
+  if (!repositoryPath) {
+    await log?.('⚠️  Development log requested but no repository path is available', { level: 'warning' });
+    return { skipped: 'missing-repository-path' };
+  }
+
+  try {
+    const artifacts = await writeDevelopmentLogArtifacts({
+      repositoryPath,
+      logFile,
+      issueNumber,
+      prNumber,
+      tool,
+      sessionId,
+      branchName,
+      rawCommand,
+    });
+
+    await log?.(`🧾 Development log artifacts written to ${artifacts.developmentLogDirectory}`);
+
+    if (!$) {
+      return { ...artifacts, committed: false, pushed: false };
+    }
+
+    const addResult = await $({ cwd: repositoryPath })`git add -f -- ${artifacts.relativeDirectory}`;
+    if (addResult.code !== 0) {
+      await log?.(`⚠️  Could not stage development log: ${getCommandOutput(addResult)}`, { level: 'warning' });
+      return { ...artifacts, committed: false, pushed: false };
+    }
+
+    const diffResult = await $({ cwd: repositoryPath })`git diff --cached --quiet -- ${artifacts.relativeDirectory}`;
+    if (diffResult.code === 0) {
+      await log?.('ℹ️  Development log artifacts already committed');
+      return { ...artifacts, committed: false, pushed: false };
+    }
+    if (diffResult.code !== 1) {
+      await log?.(`⚠️  Could not inspect staged development log changes: ${getCommandOutput(diffResult)}`, { level: 'warning' });
+      return { ...artifacts, committed: false, pushed: false };
+    }
+
+    const commitMessage = prNumber ? `Add development log for issue #${issueNumber} PR #${prNumber}` : `Add development log for issue #${issueNumber}`;
+    const commitResult = await $({ cwd: repositoryPath })`git commit -m ${commitMessage} -- ${artifacts.relativeDirectory}`;
+    if (commitResult.code !== 0) {
+      await log?.(`⚠️  Could not commit development log: ${getCommandOutput(commitResult)}`, { level: 'warning' });
+      return { ...artifacts, committed: false, pushed: false };
+    }
+
+    await log?.('✅ Development log committed');
+
+    if (!branchName) {
+      await log?.('ℹ️  Development log committed locally; no branch name available for push');
+      return { ...artifacts, committed: true, pushed: false };
+    }
+
+    const pushResult = await $({ cwd: repositoryPath })`git push origin ${branchName}`;
+    if (pushResult.code !== 0) {
+      await log?.(`⚠️  Could not push development log commit: ${getCommandOutput(pushResult)}`, { level: 'warning' });
+      return { ...artifacts, committed: true, pushed: false };
+    }
+
+    await log?.('✅ Development log pushed');
+    return { ...artifacts, committed: true, pushed: true };
+  } catch (error) {
+    await log?.(`⚠️  Development log collection failed: ${error.message}`, { level: 'warning' });
+    return { skipped: 'error', error };
+  }
+};

package/src/gemini.prompts.lib.mjs

@@ -8,6 +8,7 @@ import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 import { buildRequestedBaseBranchDirective } from './solve-option-contract.prompts.lib.mjs';
+import { buildDevelopmentLogPrompt } from './development-log.lib.mjs';
 
 /**
  * Build the user prompt for Gemini
@@ -57,6 +58,11 @@ export const buildUserPrompt = params => {
     promptLines.push('');
   }
 
+  const developmentLogPrompt = buildDevelopmentLogPrompt({ argv, issueNumber, prNumber }).trim();
+  if (developmentLogPrompt) {
+    promptLines.push(developmentLogPrompt, '');
+  }
+
   const thinkingPromptInstruction = getThinkingPromptInstruction({ tool: 'gemini', argv });
   if (thinkingPromptInstruction) {
     promptLines.push(thinkingPromptInstruction);

package/src/lib.mjs

@@ -937,6 +937,19 @@ export default {
   setupStdioLogInterceptor,
 };
 
+// Issue #1596: log the solve startup banner (version + raw command) and return
+// the raw command string for reuse. Extracted from solve.mjs to keep that file
+// under the 1500-line limit enforced by scripts/check-file-line-limits.sh.
+export const logSolveStartup = async versionInfo => {
+  const rawCommand = process.argv.join(' ');
+  await log('');
+  await log(`🚀 solve v${versionInfo}`);
+  await log('🔧 Raw command executed:');
+  await log(`   ${rawCommand}`);
+  await log('');
+  return rawCommand;
+};
+
 /**
  * Get version information for logging
  * @returns {Promise<string>} Version string

package/src/locales/en.lino

@@ -578,7 +578,7 @@ en
         branch
           option "• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)"
       think
-        option "• `--think <level>` - Thinking level (off/low/medium/high/xhigh/max) | `--thinking-budget <num>` - Token budget (0-63999)"
+        option "• `--think <level>` - Thinking level (off/low/medium/high/xhigh/ultra/max) | `--thinking-budget <num>` - Token budget (0-63999)"
       verbose
         option "• `--verbose` or `-v` - Verbose output | `--attach-logs` - Attach logs to PR"
       show

package/src/locales/hi.lino

@@ -578,7 +578,7 @@ hi
         branch
           option "• `--base-branch <branch>` या `-b` - PR के लिए target branch (default: repo default branch)"
       think
-        option "• `--think <level>` - thinking level (off/low/medium/high/xhigh/max) | `--thinking-budget <num>` - token budget (0-63999)"
+        option "• `--think <level>` - thinking level (off/low/medium/high/xhigh/ultra/max) | `--thinking-budget <num>` - token budget (0-63999)"
       verbose
         option "• `--verbose` या `-v` - verbose output | `--attach-logs` - logs को PR से attach करें"
       show

package/src/locales/ru.lino

@@ -578,7 +578,7 @@ ru
         branch
           option "• `--base-branch <branch>` или `-b` - Целевая ветка для PR (по умолчанию ветка репозитория)"
       think
-        option "• `--think <level>` - уровень размышления (off/low/medium/high/xhigh/max) | `--thinking-budget <num>` - бюджет токенов (0-63999)"
+        option "• `--think <level>` - уровень размышления (off/low/medium/high/xhigh/ultra/max) | `--thinking-budget <num>` - бюджет токенов (0-63999)"
       verbose
         option "• `--verbose` или `-v` - подробный вывод | `--attach-logs` - прикрепить логи к PR"
       show

package/src/locales/zh.lino

@@ -578,7 +578,7 @@ zh
         branch
           option "• `--base-branch <branch>` 或 `-b` - PR 目标分支（默认：仓库默认分支）"
       think
-        option "• `--think <level>` - 思考级别（off/low/medium/high/xhigh/max）| `--thinking-budget <num>` - token 预算（0-63999）"
+        option "• `--think <level>` - 思考级别（off/low/medium/high/xhigh/ultra/max）| `--thinking-budget <num>` - token 预算（0-63999）"
       verbose
         option "• `--verbose` 或 `-v` - 详细输出 | `--attach-logs` - 将日志附加到 PR"
       show

package/src/models/index.mjs

@@ -192,7 +192,7 @@ export const defaultModels = {
   claude: 'sonnet',
   agent: 'nemotron-3-super-free', // Issue #1563: changed from qwen3.6-plus-free (free promotion ended) per agent PR #243
   opencode: 'grok-code-fast-1',
-  codex: 'gpt-5.5',
+  codex: 'gpt-5.6-sol', // Issue #2027: GPT-5.6 Sol is the released Codex flagship; runtime falls back to gpt-5.5 when Sol is not in the local catalog
   qwen: 'qwen3-coder-plus',
   gemini: 'flash',
 };
@@ -366,7 +366,10 @@ export const getDefaultModelForTool = tool => {
 };
 
 let cachedInstalledCodexModelsPromise = null;
-const CODEX_DEFAULT_FALLBACK_CHAIN = ['openai.gpt-5.5', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna', 'openai.gpt-5.6-sol', 'openai.gpt-5.6-terra', 'openai.gpt-5.6-luna', 'gpt-5.4', 'openai.gpt-5.4', 'gpt-5.5-mini', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.3-codex-spark', 'gpt-5.2', 'gpt-5.2-codex', 'gpt-5.5-nano', 'gpt-5.4-nano'];
+// Issue #2027: With gpt-5.6-sol as the preferred default, the fallback chain is only
+// consulted when Sol is absent from the local catalog. Prefer the previous stable
+// default (gpt-5.5) first, then the remaining GPT-5.6 preview tiers, then older models.
+const CODEX_DEFAULT_FALLBACK_CHAIN = ['gpt-5.5', 'openai.gpt-5.5', 'gpt-5.6-terra', 'gpt-5.6-luna', 'openai.gpt-5.6-sol', 'openai.gpt-5.6-terra', 'openai.gpt-5.6-luna', 'gpt-5.4', 'openai.gpt-5.4', 'gpt-5.5-mini', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.3-codex-spark', 'gpt-5.2', 'gpt-5.2-codex', 'gpt-5.5-nano', 'gpt-5.4-nano'];
 
 export const getInstalledCodexModels = async () => {
   if (!cachedInstalledCodexModelsPromise) {
@@ -490,7 +493,7 @@ export const getValidModelsForTool = tool => {
 export const primaryModelNames = {
   claude: ['opus', 'sonnet', 'haiku', 'opusplan', 'fable'],
   opencode: ['grok', 'gpt4o'],
-  codex: ['gpt-5.5', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex-spark'],
+  codex: ['gpt-5.6-sol', 'gpt-5.5', 'gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex-spark'],
   agent: ['nemotron-3-super-free', 'minimax-m2.5-free', 'big-pickle', 'gpt-5-nano', 'glm-5-free', 'deepseek-r1-free'],
   qwen: ['qwen3-coder-plus', 'qwen3-coder', 'qwen3-coder-flash'],
   gemini: ['flash', 'pro', 'flash-lite', 'auto'],

package/src/opencode.prompts.lib.mjs

@@ -8,6 +8,7 @@ import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 import { buildRequestedBaseBranchDirective } from './solve-option-contract.prompts.lib.mjs';
+import { buildDevelopmentLogPrompt } from './development-log.lib.mjs';
 
 /**
  * Build the user prompt for OpenCode
@@ -66,6 +67,11 @@ export const buildUserPrompt = params => {
     promptLines.push('');
   }
 
+  const developmentLogPrompt = buildDevelopmentLogPrompt({ argv, issueNumber, prNumber }).trim();
+  if (developmentLogPrompt) {
+    promptLines.push(developmentLogPrompt, '');
+  }
+
   const thinkingPromptInstruction = getThinkingPromptInstruction({ tool: 'opencode', argv });
   if (thinkingPromptInstruction) {
     promptLines.push(thinkingPromptInstruction);

package/src/option-suggestions.lib.mjs

@@ -207,6 +207,7 @@ const KNOWN_OPTION_NAMES = [
   'prompt-issue-reporting',
   'prompt-architecture-care',
   'prompt-case-studies',
+  'development-log',
   'use-handoff',
   'prompt-playwright-mcp',
   'prompt-check-sibling-pull-requests',

package/src/qwen.prompts.lib.mjs

@@ -8,6 +8,7 @@ import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 import { buildRequestedBaseBranchDirective } from './solve-option-contract.prompts.lib.mjs';
+import { buildDevelopmentLogPrompt } from './development-log.lib.mjs';
 
 /**
  * Build the user prompt for Qwen Code
@@ -57,6 +58,11 @@ export const buildUserPrompt = params => {
     promptLines.push('');
   }
 
+  const developmentLogPrompt = buildDevelopmentLogPrompt({ argv, issueNumber, prNumber }).trim();
+  if (developmentLogPrompt) {
+    promptLines.push(developmentLogPrompt, '');
+  }
+
   const thinkingPromptInstruction = getThinkingPromptInstruction({ tool, argv });
   if (thinkingPromptInstruction) {
     promptLines.push(thinkingPromptInstruction);

package/src/solve.config.lib.mjs

@@ -299,13 +299,18 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   think: {
     type: 'string',
-    description: 'Thinking level hint. For Claude, translated to --thinking-budget for Claude Code >= 2.1.12 (off=0, low=~8000, medium=~16000, high=~24000, xhigh/max=31999) and to CLAUDE_CODE_EFFORT_LEVEL when supported. Fable 5/Mythos 5/Sonnet 5/Opus 4.8/4.7 support xhigh and max; Opus 4.6/Sonnet 4.6/Mythos Preview support max; Opus 4.5 uses high for xhigh/max. For Codex, mapped to reasoning effort (off=none, low=low, medium=medium, high=high, xhigh/max=xhigh).',
-    choices: ['off', 'low', 'medium', 'high', 'xhigh', 'max'],
+    description: 'Thinking level hint. For Claude, translated to --thinking-budget for Claude Code >= 2.1.12 (off=0, low=~8000, medium=~16000, high=~24000, xhigh/ultra/max=31999) and to CLAUDE_CODE_EFFORT_LEVEL when supported. Fable 5/Mythos 5/Sonnet 5/Opus 4.8/4.7 support xhigh and max; Opus 4.6/Sonnet 4.6/Mythos Preview support max; Opus 4.5 uses high for xhigh/max. `ultra` maps to the highest supported Claude effort (Claude "ultracode"-class reasoning). For Codex (GPT-5.6 Sol), mapped 1:1 to reasoning effort (off=none, low=low, medium=medium, high=high, xhigh=xhigh, ultra=ultra, max=max); GPT-5.6 keeps xhigh and adds max above it, and ultra runs the multi-agent mode paired with a rollout token budget cap. Default: no thinking level is enforced (models run as-is).',
+    choices: ['off', 'low', 'medium', 'high', 'xhigh', 'ultra', 'max'],
     default: undefined,
   },
   'thinking-budget': {
     type: 'number',
-    description: 'Thinking token budget. For Claude Code, controls MAX_THINKING_TOKENS (0-31999 by default). For Codex, enables finer reasoning-effort mapping including minimal/low/medium/high/xhigh.',
+    description: 'Thinking token budget. For Claude Code, controls MAX_THINKING_TOKENS (0-31999 by default). For Codex, enables finer reasoning-effort mapping (minimal/low/medium/high) capped at xhigh; the deepest single-agent `max` and the multi-agent `ultra` effort must be requested explicitly via --think max / --think ultra.',
+    default: undefined,
+  },
+  'rollout-token-budget': {
+    type: 'number',
+    description: "Codex rollout token budget (turn-level cap) paired with the multi-agent `--think ultra` effort so GPT-5.6 Sol's ultra mode stays predictable and does not run away on cost. Default: 500000. Only applied when --think ultra selects the ultra reasoning effort.",
     default: undefined,
   },
   'thinking-budget-claude-minimum-version': {
@@ -499,6 +504,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Create comprehensive case study documentation for the issue including logs, analysis, timeline, root cause investigation, and proposed solutions. Organizes findings into ./docs/case-studies/issue-{id}/ directory. Supported for --tool claude and --tool codex.',
     default: false,
   },
+  'development-log': {
+    type: 'boolean',
+    description: 'Prompt for issue-data collection under ./dev/log/issues/{issue-id}/pulls/{pull-id}, preserve native tool state under sessions/{UUID}, and commit the artifacts when solve finishes. Supported for --tool claude, --tool codex, --tool opencode, --tool agent, --tool qwen, and --tool gemini.',
+    default: false,
+  },
   'use-handoff': {
     type: 'boolean',
     description: '[EXPERIMENTAL] Enable the HANDOFF.md continuity Agent Skill so a session can continue the work of a previous session — even when a different AI tool is used (e.g. Claude and Codex continuing each other in the same pull request). A real SKILL.md (the open Agent Skills standard) is deployed into the working directory so each tool loads it natively (.claude/skills/handoff/ for Claude, .agents/skills/handoff/ for Codex). The AI reads HANDOFF.md (repository root) first when present and keeps it updated with task, current state, decisions, next steps, gotchas, and critical files. HANDOFF.md is committed to the PR branch so it persists across the ephemeral per-session working directories; the SKILL.md itself is re-deployed each session and git-excluded so it never pollutes the PR. The same skill file is used identically for --tool claude and --tool codex. Disabled by default (issue #1877).',

package/src/solve.mjs

@@ -21,7 +21,7 @@ const fs = (await use('fs')).promises;
 const crypto = (await use('crypto')).default;
 const memoryCheck = await import('./memory-check.mjs');
 const lib = await import('./lib.mjs');
-const { log, setLogFile, getLogFile, getAbsoluteLogPath, cleanErrorMessage, formatAligned, formatToolExecutionFailure, getVersionInfo, setupVerboseLogInterceptor, setupStdioLogInterceptor } = lib;
+const { log, setLogFile, getLogFile, getAbsoluteLogPath, cleanErrorMessage, formatAligned, formatToolExecutionFailure, getVersionInfo, logSolveStartup, setupVerboseLogInterceptor, setupStdioLogInterceptor } = lib;
 const githubLib = await import('./github.lib.mjs');
 const { sanitizeLogContent, attachLogToGitHub, getToolDisplayName } = githubLib;
 const validation = await import('./solve.validation.lib.mjs');
@@ -62,6 +62,8 @@ const { recordAfterCloneSize, recordAfterAgentSize } = await import('./solve.dis
 const { createOrCheckoutBranch } = await import('./solve.branch.lib.mjs');
 const { startWorkSession, endWorkSession, SESSION_TYPES } = await import('./solve.session.lib.mjs');
 const { attachFinalLogIfMissing } = await import('./attach-logs-guarantee.lib.mjs'); // Issue #1952
+const { collectAndCommitDevelopmentLogArtifacts, fetchIssueType, isDevelopmentLogEnabled } = await import('./development-log.lib.mjs');
+const { createDevelopmentLogFinalizer } = await import('./development-log.finalize.lib.mjs');
 // Issue #1625: centralized markers + tracked comment posting for solve.mjs's
 // own usage-limit notifications (so they're excluded from the
 // "did the AI post anything?" check in --auto-attach-solution-summary).
@@ -72,12 +74,7 @@ const { autoAcceptInviteForRepo } = await import('./solve.accept-invite.lib.mjs'
 const { handleAutoForkOption, handleMaintainerForkAccess } = await import('./solve.fork-detection.lib.mjs');
 const logFile = await initializeLogFile(null);
 const versionInfo = await getVersionInfo();
-await log('');
-await log(`🚀 solve v${versionInfo}`);
-const rawCommand = process.argv.join(' ');
-await log('🔧 Raw command executed:');
-await log(`   ${rawCommand}`);
-await log('');
+const rawCommand = await logSolveStartup(versionInfo);
 
 let finalResourceSnapshotRecorded = false;
 const safeExit = async (code = 0, reason = 'Process completed', options = {}) => {
@@ -489,6 +486,8 @@ if (isPrUrl) {
 }
 // Issues #1212, #1462: Store issueNumber globally for error handlers (attach failure logs to issue when no PR exists)
 global.issueNumber = issueNumber;
+// Issue #1596: detect the issue type so the development-log prompt automatically uses bug vs feature/task wording.
+if (isDevelopmentLogEnabled(argv) && issueNumber) argv.issueType = await fetchIssueType({ owner, repo, issueNumber, $, log });
 const workspaceInfo = argv.enableWorkspaces ? { owner, repo, issueNumber } : null;
 const { tempDir, workspaceTmpDir, needsClone } = await setupTempDirectory(argv, workspaceInfo);
 cleanupContext.tempDir = tempDir;
@@ -497,6 +496,12 @@ cleanupContext.owner = owner;
 cleanupContext.repo = repo;
 if (prNumber) cleanupContext.prNumber = prNumber;
 let limitReached = false;
+let sessionId = null;
+let branchName = null;
+const finalizeDevelopmentLog = createDevelopmentLogFinalizer({
+  collect: collectAndCommitDevelopmentLogArtifacts,
+  getParams: () => ({ enabled: isDevelopmentLogEnabled(argv), repositoryPath: tempDir, logFile: getLogFile(), issueNumber, prNumber, tool: argv.tool || 'claude', sessionId, branchName, rawCommand, $, log }), // prettier-ignore
+});
 try {
   // Set up repository and clone using the new module
   // If --working-directory points to existing repo, needsClone is false and we skip cloning
@@ -531,7 +536,7 @@ try {
     issueUrl,
   });
   // Create or checkout branch using the new module
-  const branchName = await createOrCheckoutBranch({
+  branchName = await createOrCheckoutBranch({
     isContinueMode,
     prBranch,
     issueNumber,
@@ -861,7 +866,7 @@ try {
   }
 
   const { success } = toolResult;
-  let sessionId = toolResult.sessionId;
+  sessionId = toolResult.sessionId;
   let anthropicTotalCostUSD = toolResult.anthropicTotalCostUSD;
   let publicPricingEstimate = toolResult.publicPricingEstimate; // Used by agent tool
   let pricingInfo = toolResult.pricingInfo; // Used by agent tool for detailed pricing
@@ -1461,17 +1466,10 @@ try {
   // Issue #1516: Cleanup after all signals (was before verifyResults, caused premature commits)
   await cleanupClaudeFile(tempDir, branchName, claudeCommitHash, argv);
 
-  // End work session using the new module
-  await endWorkSession({
-    isContinueMode,
-    prNumber,
-    argv,
-    log,
-    formatAligned,
-    $,
-    logsAttached,
-  });
+  await finalizeDevelopmentLog(); // Issue #1596: preserve session before ending work.
+  await endWorkSession({ isContinueMode, prNumber, argv, log, formatAligned, $, logsAttached });
 } catch (error) {
+  await finalizeDevelopmentLog(); // Preserve failed/interrupted sessions too.
   // Don't report authentication errors to Sentry as they are user configuration issues
   if (!error.isAuthError) {
     reportError(error, {

package/src/thinking-prompt.lib.mjs

@@ -8,6 +8,7 @@ export const THINK_PROMPT_MESSAGES = Object.freeze({
   medium: 'Think hard.',
   high: 'Think harder.',
   xhigh: 'Ultrathink.',
+  ultra: 'Ultrathink.',
   max: 'Ultrathink.',
 });