codexteer 0.18.0 → 0.18.2

package/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
-## Unreleased
+公開日は日本時間です。
+
+## 0.18.2 — 2026-11-01公開
+
+- 停止済みの監督IDが、別の監督への交代後に古い本文から再登録できる問題を修正しました。停止履歴を監督記録に保持し、登録前のdoctor・再登録・観測・送信で`SUPERVISOR_STOPPED`を返します。旧形式の停止済み記録も、交代時に履歴へ引き継ぎます。保存済み旧CLIを使う監督には、更新後のCLIでプロンプトを生成し直してください。
+- 同じ監督IDの別タスクへの登録を拒否します。既存データでIDが重複している場合も`supervise list --json`は全件を返し、`session_conflict.thread_ids`と、他タスクの観測記録を除外した項目の`observation_error`で衝突を示します。各タスクの`supervise stop`で停止できます。
+
+## 0.18.1 — 2026-10-31
+
+- ローカルロックの保持者と回収者が続けてクラッシュした後、`RECORD_BUSY`から自動回復できなくなる問題を修正しました。回収処理にもPIDと世代トークンを持つロックを使い、生きた保持者・回収者の排他を維持します。
+- 更新前に、同じ`CODEX_HOME`を使う旧版CLIの操作と、保存済み旧CLIで動く監督を終了してください。旧版と修正版の回収方式を混在させることはできません。残った旧`.recover`ディレクトリは修正版の動作を妨げません。更新後に監督を起動し直すか、プロンプトを生成し直してください。
+
+## 0.18.0 — 2026-10-29公開
 
 - `thread repair <THREAD>`で古いターンの終了記録欠落を検出します。明示的な`--apply`はCodexの完全終了・検証済みバージョンを必須とし、バックアップ後に対象IDの中断記録だけを追記・照合します。既存の会話やDBは書き換えず、最新の未完了ターンは修復しません。
 - macOS向けに`desktop update`と`desktop update-status`を追加しました。独立したworkerが公式更新UI（英語・日本語）を操作し、新ビルドと再起動を確認してから共有wrapperを再適用・検証します。外部NodeとターミナルのAccessibility・Automation権限が必要です。
@@ -13,21 +25,21 @@
 - POSIXパスの大文字小文字を保持し、CLIの宛先はオプション値ではなく位置引数から選択します。監督の制御は登録時のtransportと一致する場合だけ受け付けます。
 - リモート作成の再照合失敗時は古い認定フラグを除去してreceiptへ記録します。実行RPCの内部エラーでは実行済みの可能性を保持し、resource leaseを解放しません。
 
-## 0.18.0 — 未公開
-
 - Cloud監督の登録前診断と、初回配送の受付不明を共通履歴から照合・回復できるよう修正しました。本文・client IDが一致する保存証拠だけを採用し、自動再送は行いません。
 
 - Desktop Cloudの所属確認をdoctorへ追加し、プロジェクト一覧と環境一覧を分離しました。署名付きのthread assignは実環境・nonce・署名・保存結果を照合します。そのDesktop実行環境への結合が必要で、通常のCloud環境の拒否を成功扱いしたり別環境へ置き換えたりしません。作成後のタイトル設定・初回配送失敗時にも通常表示へ作成済みIDと復旧情報を残します。
 
 - Desktop Cloudの環境構成一覧・新規作成・継続送信・共通監視を追加しました。初回送信にも選択済み環境と遅延起動指定を保持します。環境選択とDesktopプロジェクト所属を区別し、所属登録が確認できない`--project`作成は事前拒否します。受付不明の自動再送は行いません。
 
-- Cloudの重複拒否で前回の試行IDを今回の配送履歴へ結び付けないよう修正しました。回復用IDを分離し、history checkは今回の本文・親ターンも照合して、拒否した指示の誤有効化を防ぎます。未公開の作成用--env別名も削除し、環境指定は--projectに統一しました。新規作成の本文がCloud ID/URLで始まっても、それを宛先と誤判定しません。
+- Cloudの重複拒否で前回の試行IDを今回の配送履歴へ結び付けないよう修正しました。回復用IDを分離し、history checkは今回の本文・親ターンも照合して、拒否した指示の誤有効化を防ぎます。作成用--env別名を削除し、環境指定は--projectに統一しました。新規作成の本文がCloud ID/URLで始まっても、それを宛先と誤判定しません。
 
 - 共通Cloud観測で公開commentaryの途中経過を保持し、途中経過だけの更新でもMonitorへ通知します。reasoning等の非公開内容は除外し、`--backend app-server`を宛先より前に置く場合のCloud振り分けも修正しました。
 
 - Cloudタスクも共通の`supervise`・`read/watch`・`send`・`history/instructions/findings`で扱えます。監督の登録・pause/resume/stop・保存済みCLI・Monitorのdigestと復帰待ちを既存基盤へ接続し、実行中の指定ターンの中断と同一タスク内での継続、配送照合を追加しました。旧Desktop CLIとの記録互換性を保つCloud専用監督名前空間を使います。
 
-- Cloud環境・タスクの一覧と新規作成は`--connection cloud projects list`・`threads list`・`thread create`で扱います。作成試行は`thread receipt`、配送照合・予約回復は`history show/check --attempt`、試行を選ぶ差分取得は`diff --attempt`に統一しました。未公開の重複サブコマンドと専用のカーソル・watch処理を削除し、結果不明時の自動再送は行いません。公式CLIの診断は私有一時領域で処理し、ローカル差分を暗黙に送信・適用しません。
+- Cloud環境・タスクの一覧と新規作成は`--connection cloud projects list`・`threads list`・`thread create`で扱います。作成試行は`thread receipt`、配送照合・予約回復は`history show/check --attempt`、試行を選ぶ差分取得は`diff --attempt`に統一しました。重複サブコマンドと専用のカーソル・watch処理を削除し、結果不明時の自動再送は行いません。公式CLIの診断は私有一時領域で処理し、ローカル差分を暗黙に送信・適用しません。
+
+## 0.17.0 — 2026-10-15公開
 
 - `projects list`と`thread create --project`を追加しました。プロジェクト名と初回指示だけで作成でき、既存チャット・`CODEX_THREAD_ID`・中継AIは不要です。App Serverで作成・Desktop購読・初回配送を行い、新規チャット自身の実在IDからnative RPCで所属登録し、全フォルダと初回指示を照合します。明示的な`--context-thread`は任意で、従来のnative直接作成を使います。配送不明・部分成功を保持し、自動再作成・再送を行いません。
 
@@ -41,7 +53,7 @@
 - `--settle-ms`と`--max-hold-ms`で待ち時間を調整できます。初回の読み取りは基準として扱い、実行中コマンドの出力だけの更新ではsettleを延長しません。保留分は接続断・終了時にも排出し、ページ途中の場合だけ`has_more:true`を保持します。200件／64KBはページ読了後の排出目安です。
 - 監督プロンプトを方針先頭の8節へ整理し、既定方針に設計上の責務と作業の焦点を追加します。設計上の責務では、事実・計算・判定を設計がどの層やシステムの担当と定めているかを先に確認し、別の層での検算や再計算など、同じ事実の持ち主が二つになる実装を観測します。基準は複数のリポジトリにまたがる設計の全体とし、分担が示されていない場合は推測せずユーザーに確認します。開始時の`help monitor`の重複読み取りをなくし、通知の読み方・無操作時の応答・Monitor期限切れ・議論の送信を明示します。生成する監視コマンドは`--notify digest`を明示します。
 
-## 0.15.1 — 未公開
+## 0.15.1 — 2026-09-13公開
 
 - ページ履歴に対応するタスクへの`send`・`send --new-turn`は、本文を含まないターン状態を分割取得して送信前に確認します。長いタスクの全履歴が64 MiBを超え、観測はできても送信準備だけ失敗する問題を修正しました。`--based-on`等の安全確認は維持します。
 - 64 MiBの受信上限を超えた場合は`PAYLOAD_TOO_LARGE`を返します。上限は維持し、送信前の`not_sent`と受付未確認の`unknown`を区別します。

package/README.md

@@ -18,7 +18,7 @@ Desktop操作にはmacOS、Node.js 20以降とnpm、`/Applications/ChatGPT.app`
 
 リポジトリのcloneやグローバルインストールなしで実行できます。npmパッケージ名とCLI名は`codexteer`です。
 
-npm公開済みの最新版は`0.17.0`です。このブランチは、リモート操作・Cloud対応などをまとめたマイナー更新`0.18.0`を準備します。公開前に使う場合は「ソースから導入する」の手順で導入してください。変更点は[CHANGELOG](CHANGELOG.md)を参照してください。
+npm公開済みの最新版は[`0.18.0`](https://www.npmjs.com/package/codexteer/v/0.18.0)です。リモート操作・Cloud対応・Desktop更新・オフライン履歴修復を含みます。変更点と各機能の条件は[CHANGELOG](CHANGELOG.md)を参照してください。
 
 ```bash
 npx -y codexteer --version
@@ -36,7 +36,7 @@ npx -y codexteer doctor --json
 <details>
 <summary>特定のバージョンで実行する場合（任意）</summary>
 
-不具合の切り分けや、同じ版で監督を開始し直したい場合は、パッケージ名に`@バージョン`を付けられます。`0.18.0`の公開後にその版を選ぶ場合は、次のように指定します。
+不具合の切り分けや、同じ版で監督を開始し直したい場合は、パッケージ名に`@バージョン`を付けられます。公開済みの`0.18.0`を選ぶ場合は、次のように指定します。
 
 ```bash
 npx -y codexteer@0.18.0 supervise <thread-id>
@@ -253,6 +253,10 @@ codexteer supervise stop <thread-id>
 
 直接起動はエージェントを起動する前に登録し、終了時に停止を記録します。本文だけの生成では未登録で、貼り付け先が本文中の`supervise register`を実行して開始します。一つのタスクに一つの監督を登録でき、競合は`SUPERVISOR_CONFLICT`になります。異常終了などで残った登録は、`status`で確認して明示的に`stop`してから開始し直してください。停止済みIDや古い本文で再開はできません。同じ本文の再登録で一時停止が解除されることもありません。
 
+停止済みIDは交代後も監督記録の履歴に保持し、登録前の`doctor`・再登録・観測・送信を`SUPERVISOR_STOPPED`で拒否します。更新前の停止済み記録も、交代時に履歴へ引き継ぎます。更新前にすでに上書きされて失われた停止履歴は復元できません。保存済み旧CLIには修正が反映されないため、更新後のCLIでプロンプトを生成し直してください。
+
+同じ`CODEX_HOME`・接続先ホストの中では、監督IDを別タスクへ登録できません（`SUPERVISOR_CONFLICT`。停止済みなら`SUPERVISOR_STOPPED`）。旧版で同じIDを複数タスクに登録したデータも、`supervise list --json`は全件を返し、該当項目の`session_conflict.thread_ids`に衝突先を示します。他タスクの観測記録は`observation: null`と`observation_error`で明示し、そのタスクの観測として扱いません。重複したIDでの観測・送信は拒否されます。ユーザーの端末から各タスクを`supervise stop`し、新しいIDの監督を開始してください。
+
 送信中の`pause`/`stop`は`RECORD_BUSY`で失敗します。配送結果を確認して制御を再実行し、成功するまでは停止したと扱わないでください。監督役が自分で`resume`したり、生成コマンドから`--supervisor`を外して回避したりしないよう、必須テンプレートにも指示します。
 
 この制御は新しい監督ID付きコマンドに適用します。以前の版で開始した監督、IDなしの手動送信、同じOSユーザーが実行する任意のコードを隔離する機能ではありません。監督IDは秘密情報ではなく、古いセッションや操作の競合を検出する識別子です。

package/docs/distribution.md

@@ -1,11 +1,16 @@
 # 配布と永続実行
 
 パッケージ名は `codexteer`、CLI名は `codexteer`、ライセンスはMITです。
-旧npmパッケージは`@vinhphatfsg/codex-steer`です。`codexteer@0.17.0`は公開済みで、このブランチはリモート操作・Cloud対応などをまとめたマイナー更新`0.18.0`を準備します。GitHubのPR作成・マージはnpm公開を行う操作ではありません。公開時は`npm whoami`でnpm側のユーザーを確認してください。
+旧npmパッケージは`@vinhphatfsg/codex-steer`です。リモート操作・Cloud対応・Desktop更新・オフライン履歴修復を含む[`codexteer@0.18.0`](https://www.npmjs.com/package/codexteer/v/0.18.0)は2026-10-29にnpmへ公開済みです。GitHubのPR作成・マージはnpm公開を行う操作ではありません。次の版を公開する際も`npm whoami`でnpm側のユーザーを確認してください。
+
+`0.18.1`は、保持者と回収者の連続クラッシュでローカルロックが永久に`RECORD_BUSY`になる問題を修正します。更新前に、同じ`CODEX_HOME`を使う旧版CLIの操作と、保存済み旧CLIで動く監督を終了してください。旧版と修正版の回収方式の混在は非対応です。旧`.recover`ディレクトリは修正版では無視されます。監督は更新後のCLIで起動し直すか、プロンプトを生成し直してください。
+
+`0.18.2`は、監督が交代した後も停止済みIDを履歴に保持し、古い本文からの再登録・観測・送信を`SUPERVISOR_STOPPED`で拒否します。登録前の`doctor`にも同じ判定を適用します。同じIDの別タスクへの登録を拒否し、旧版で重複したIDを持つ記録も`supervise list --json`で全件と衝突先を返します。該当タスクはそれぞれ`supervise stop`で停止できます。更新前の停止済み記録は交代時に引き継ぎますが、すでに上書きされて失われた停止履歴は復元できません。保存済み旧CLIには修正が反映されないため、更新後のCLIで監督を起動し直すか、プロンプトを生成し直してください。runtime protocolとcapability契約はv1を維持し、Desktopの再起動は必要ありません。
+
 `package.json` は `private` を持たず、`publishConfig` でnpm公式レジストリへのpublic公開を指定しています。公開可能な設定であることと、実際に公開済みであることは別です。
 
 公開後の基本的な実行形式は次のとおりです。通常はバージョン指定なしで使えます。監督開始後は保存したCLIを使い続けるため、監督中の一貫性を保つために版を明示する必要はありません。起動側と操作側の製品バージョンも、必要な通信仕様が対応していれば異なっていても使えます。
-以下の監督機能は公開済みの0.15.0から利用できます。0.16.0では通知集約と監督プロンプトを改善しました。0.18.0のチャット作成機能は公開準備中のため、公開前はこのブランチをソースから導入してください。`-y` はnpmの取得確認を省略します。
+以下の監督機能は公開済みの0.15.0から利用できます。0.16.0では通知集約と監督プロンプトを改善し、0.17.0でDesktopのチャット作成、0.18.0でリモート操作・Cloud対応などを追加しました。いずれもnpmから利用できます。`-y` はnpmの取得確認を省略します。
 
 ```text
 npx -y codexteer desktop start
@@ -179,7 +184,7 @@ npxから模擬Claudeと模擬Codexを起動して保存したCLIへの参照を
 
 レビュー・検証を終えた版を、npm側の公開権限を持つアカウントで公開します。手動公開には2FAを有効にしたアカウントを使ってください。
 
-公開済みのパッケージ名とバージョンの組み合わせは再公開できません。既存の`codexteer@0.17.0`は変更せず、今回の配布物は`codexteer@0.18.0`として準備します。公開は別途実行します。削除しても同じ名前・版番号の組み合わせを再利用できません。[npm publishの仕様](https://docs.npmjs.com/cli/v11/commands/npm-publish/)
+公開済みのパッケージ名とバージョンの組み合わせは再公開できません。`codexteer@0.18.0`は公開済みのため、次の変更をnpmへ配布する際は新しい版番号を使います。削除しても同じ名前・版番号の組み合わせを再利用できません。[npm publishの仕様](https://docs.npmjs.com/cli/v11/commands/npm-publish/)
 
 ```bash
 npm login
@@ -188,7 +193,7 @@ npm run test:package
 npm publish --access public
 ```
 
-公開後は、公開した版と起動コマンドの登録を確認します。次は0.18.0を公開した場合の例です。
+公開後は、公開した版と起動コマンドの登録を確認します。公開済みの0.18.0は次のコマンドで確認できます。
 
 ```bash
 npm view codexteer@0.18.0 version bin --json
@@ -218,10 +223,10 @@ npx -y codexteer@0.18.0 --version
 
 開発用の`npm run test:connection`は、Desktop同梱CLIを一時プロファイルのUnixソケットで起動し、ローカル偽モデルで作った合成履歴の読み取りを確認します。実Desktopへの接続・設定変更や外部モデル利用は行いません。`npm run test:protocol`は既存wrapper・偽Desktopとの送信と承認経路、`npm run test:package`は実tarball・オフラインnpx・偽Claude/Codexの起動と、別CODEX_HOME・キャッシュ削除後の観測/送信・pause/resume・重複拒否を確認します。これらの隔離検証から実Desktopの表示や直接接続での承認往復まで保証するものではありません。
 
-## 0.18.0の公開候補
+## 0.18.0の公開結果
 
-`package.json`と`package-lock.json`の版を0.18.0に揃えています。0.17.0はnpm registryで公開済みであることを確認し、同じ版への上書き公開は行いません。`projects list`と`thread create --project`、Desktopの所属登録、全フォルダと初回指示の照合を追加します。既存のruntime protocolとcapability契約はv1を維持します。
+0.18.0公開時の`package.json`と`package-lock.json`の版、およびnpm registryの`latest`は0.18.0でした。公開tarballが事前検証したファイルと同一であることを確認しました。0.18.0にはリモート操作・Cloud対応・Desktop更新・オフライン履歴修復を含みます。`projects list`と`thread create --project`によるDesktopのチャット作成は0.17.0から利用できます。既存のruntime protocolとcapability契約はv1を維持します。
 
-公開前に構文・全回帰・tarballとoffline install・npm/npx・publish dry-runを確認します。公開するファイルを固定する場合は、検証済みtarballのSHA-256を照合してから同じtarballを公開してください。PRのReady化やバージョン更新だけではnpmへ公開されません。
+公開前に構文・全回帰・tarballとoffline install・npm/npx・publish dry-runを検証しました。公開対象119ファイルの内部情報・シークレット検査と依存脆弱性監査で検出は0件でした。公開後はregistryから取得したtarballのSHA-256一致と、隔離キャッシュからのCLI起動を確認しました。次の版でも検証済みtarballを固定して公開してください。PRのReady化やバージョン更新だけではnpmへ公開されません。
 
 検証結果の要約は`remote-cli-validation.json`を参照してください。実環境のホスト・プロジェクト・チャット識別子、ローカルパス、診断ログは公開用の配布物へ含めません。npm公開・Gitタグ作成はPR更新とは別の操作です。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexteer",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "description": "Send steering messages to running Codex Desktop threads from a terminal.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -15,7 +15,7 @@ import { acquireResource, resourceStatus, renewResource, releaseResource, listRe
 import { playSendSound } from "./sound.mjs";
 import { prepareSupervisorPrompt, superviseAgent } from "./supervise.mjs";
 import { prepareOrchestrationPrompt, orchestrateAgent } from "./orchestrate.mjs";
-import { supervisorId, registerSupervisor, getSupervisor, assertSupervisor, controlSupervisor, supervisorStatus, listSupervisors } from "./supervision.mjs";
+import { supervisorId, registerSupervisor, getSupervisor, assertSupervisor, assertSupervisorRegistration, controlSupervisor, supervisorStatus, listSupervisors } from "./supervision.mjs";
 import { createFinding, findingStatus, listFindings, resolveFinding, dismissFinding, reopenFinding, evaluateFinding, findingStats } from "./findings.mjs";
 import { connectionMode, observationConnection, desktopReadOnly } from "./connection.mjs";
 import { repairTurns } from "./turn-repair.mjs";
@@ -141,7 +141,7 @@ function printThreads(threads) {
 function printSupervisor(data) {
   if (Array.isArray(data)) {
     if (!data.length) console.log("No supervisor sessions registered.");
-    for (const entry of data) console.log(`${entry.thread_id}  ${entry.state}  ${entry.owner}  ${entry.connection}  observed:${entry.observation?.last_observed_at ?? "none"}`);
+    for (const entry of data) console.log(`${entry.thread_id}  ${entry.state}  ${entry.owner}  ${entry.connection}  observed:${entry.observation?.last_observed_at ?? "none"}${entry.session_conflict ? `  session-conflict:${entry.session_conflict.thread_ids.join(",")}` : ""}${entry.observation_error ? `  observation-error:${entry.observation_error.code}` : ""}`);
     return;
   }
   console.log(`${data.thread_id}  ${data.state}${data.owner ? `  ${data.owner}  ${data.connection}` : ""}`);
@@ -459,11 +459,7 @@ async function mainOnTarget(argv) {
       const target = takeOption(args, "--thread", undefined);
       if (target !== undefined && backend !== "app-server") throw new Error("doctor --thread requires --backend app-server.");
       const threadId = target === undefined ? undefined : normalizeThreadId(target);
-      if (supervisor && threadId) {
-        const record = await getSupervisor(threadId);
-        if (record && record.session_id !== supervisor && record.state !== "stopped") throw Object.assign(new Error("Another supervisor is registered for this task."), { code: "SUPERVISOR_CONFLICT" });
-        if (record?.session_id === supervisor) await assertSupervisor(threadId, supervisor, { connection });
-      }
+      if (supervisor && threadId) await assertSupervisorRegistration(threadId, supervisor, { connection });
       if (args.length) throw new Error(`Unexpected argument: ${args[0]}`);
       if (targetHost() !== "local" && backend === "ui") throw remoteReadOnly();
       const report = backend === "ui" ? desktopDoctor() : await appServerDoctor({ threadId, ...connectionDependencies });

package/src/cloud-cli.mjs

@@ -10,7 +10,7 @@ import { observeThread, printObservation } from "./observe.mjs";
 import { monitorCommand } from "./monitor.mjs";
 import { notificationOptions } from "./notify.mjs";
 import { prepareSupervisorPrompt, superviseAgent } from "./supervise.mjs";
-import { supervisorId, registerSupervisor, getSupervisor, assertSupervisor, controlSupervisor, supervisorStatus, listSupervisors } from "./supervision.mjs";
+import { supervisorId, registerSupervisor, getSupervisor, assertSupervisor, assertSupervisorRegistration, controlSupervisor, supervisorStatus, listSupervisors } from "./supervision.mjs";
 import { createFinding, findingStatus, listFindings, resolveFinding, dismissFinding, reopenFinding, evaluateFinding, findingStats } from "./findings.mjs";
 import { sendTrackedMessage, listMessages, getMessage, messageSummary, reconcileMessages, markMessage, listInstructions } from "./journal.mjs";
 import { createCloudTask, cloudTaskDiff, listCloudTasks, cloudCreationReceipt } from "./cloud.mjs";
@@ -84,9 +84,8 @@ export async function mainCloud(argv) {
   const bound = async (target, { allowUnregistered = false } = {}) => {
     const id = targetId(target);
     if (supervisor) {
-      const record = allowUnregistered ? await getSupervisor(id) : null;
-      if (!allowUnregistered || record?.session_id === supervisor) await assertSupervisor(id, supervisor, { connection });
-      else if (record && record.state !== "stopped") throw failure("Another supervisor owns this cloud task.", "SUPERVISOR_CONFLICT");
+      if (allowUnregistered) await assertSupervisorRegistration(id, supervisor, { connection });
+      else await assertSupervisor(id, supervisor, { connection });
     }
     return id;
   };

package/src/store.mjs

@@ -1,5 +1,5 @@
 import { lstat, mkdir, readFile, writeFile, rename, rm, readdir, link } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
 import { codexHome, isAlive } from "./runtime.mjs";
 import { hostNamespace, hostFields } from "./target.mjs";
@@ -51,22 +51,31 @@ export async function listRecords(bucket, options = {}) {
 }
 
 export async function withStoreLock(key, fn, { home = codexHome() } = {}) {
-  await directory("locks", home, true);
-  const file = storePath("locks", key, home), token = randomUUID(), temp = `${file}.${token}.tmp`;
+  return withRecordLock("locks", key, fn, { home });
+}
+
+async function withRecordLock(bucket, key, fn, { home }) {
+  await directory(bucket, home, true);
+  const file = storePath(bucket, key, home), token = randomUUID(), temp = `${file}.${token}.tmp`;
   await writeFile(temp, JSON.stringify({ token, pid: process.pid }), { mode: 0o600, flag: "wx" });
   let acquired = false;
   let outcome;
   try {
     for (let attempt = 0; attempt < 2; attempt++) {
       try { await link(temp, file); acquired = true; break; } catch (e) { if (e.code !== "EEXIST") throw e; }
-      const old = await readRecord("locks", key, { home });
+      const old = await readRecord(bucket, key, { home });
       if (old && !isAlive(old.pid)) {
-        const recovery = `${file}.recover`;
-        try { await mkdir(recovery, { mode: 0o700 }); } catch (e) { if (e.code !== "EEXIST") throw e; break; }
-        try {
-          const current = await readRecord("locks", key, { home });
+        // Serialize deletion of this generation, including recovery of a crashed
+        // recoverer. Each nested lock has an atomically published PID + token.
+        // A finite chain of dead owners ends at an absent recovery lock.
+        // Legacy .recover directories have no owner and are unsupported/inert.
+        // Stop all old-version operations (including saved supervisor CLIs)
+        // sharing this CODEX_HOME before using this recovery protocol.
+        const recoveryKey = createHash("sha256").update(String(old.token)).digest("hex");
+        await withRecordLock("lock-recovery", recoveryKey, async () => {
+          const current = await readRecord(bucket, key, { home });
           if (current?.token === old.token && !isAlive(current.pid)) await rm(file);
-        } finally { await rm(recovery, { recursive: true }); }
+        }, { home });
       } else break;
     }
     if (!acquired) throw Object.assign(new Error("Another operation owns this local record. Retry after it finishes."), { code: "RECORD_BUSY" });
@@ -74,7 +83,7 @@ export async function withStoreLock(key, fn, { home = codexHome() } = {}) {
     return outcome;
   } finally {
     try {
-      if (acquired && (await readRecord("locks", key, { home }))?.token === token) await rm(file);
+      if (acquired && (await readRecord(bucket, key, { home }))?.token === token) await rm(file);
       await rm(temp, { force: true });
     } catch { if (outcome && typeof outcome === "object") outcome.state_cleanup_required = true; }
   }

package/src/supervision.mjs

@@ -21,12 +21,35 @@ export function supervisorId(value) {
   return value.toLowerCase();
 }
 
+// Keep retired generations in the same atomic record as the current owner.
+// A legacy stopped record contributes its ID even before its first rewrite.
+function stoppedSessionIds(record) {
+  return [...new Set([...(record?.stopped_session_ids ?? []), ...(record?.state === "stopped" ? [record.session_id] : [])])];
+}
+
+function assertNotStopped(record, sessionId) {
+  if (stoppedSessionIds(record).includes(sessionId)) throw failure("This supervisor session has stopped. Start a new supervisor when needed.", "SUPERVISOR_STOPPED");
+}
+
+async function supervisorRecords(storage) {
+  return (await Promise.all([listRecords("supervisors", storage), listRecords("cloud-supervisors", storage)])).flat().filter(Boolean);
+}
+
+async function assertSessionBinding(threadId, sessionId, storage) {
+  const others = (await supervisorRecords(storage)).filter(record => record.thread_id !== threadId);
+  // A stopped ID stays retired even when a caller changes its target task.
+  for (const record of others) assertNotStopped(record, sessionId);
+  if (others.some(record => record.session_id === sessionId)) throw failure("This supervisor session is already registered for another task. Start a new supervisor for this task.", "SUPERVISOR_CONFLICT");
+}
+
 export async function getSupervisor(threadInput, storage = {}) {
   const threadId = normalizeTaskId(threadInput), record = await readRecord(supervisorBucket(threadId), threadId, storage);
   if (!record) return null;
   if (record.schema !== 1 || record.thread_id !== threadId || !states.has(record.state)
     || !["shared", "desktop", "cloud", "desktop-cloud"].includes(record.connection)
     || supervisorId(record.session_id) !== record.session_id || typeof record.owner !== "string"
+    || (record.stopped_session_ids !== undefined && (!Array.isArray(record.stopped_session_ids)
+      || record.stopped_session_ids.some(id => supervisorId(id) !== id)))
     || (record.launcher_pid !== null && (!Number.isSafeInteger(record.launcher_pid) || record.launcher_pid <= 0))) {
     throw failure("Invalid supervisor state. Inspect the local record before continuing.", "SUPERVISOR_INVALID");
   }
@@ -34,35 +57,45 @@ export async function getSupervisor(threadInput, storage = {}) {
 }
 
 export async function assertSupervisor(threadInput, sessionInput, { sending = false, connection, ...storage } = {}) {
-  const sessionId = supervisorId(sessionInput), record = await getSupervisor(threadInput, storage);
+  const threadId = normalizeTaskId(threadInput), sessionId = supervisorId(sessionInput), record = await getSupervisor(threadId, storage);
+  assertNotStopped(record, sessionId);
+  await assertSessionBinding(threadId, sessionId, storage);
   if (!record) throw failure("Register this supervisor session before observing or sending.", "SUPERVISOR_NOT_REGISTERED");
   if (record.session_id !== sessionId) throw failure("Another supervisor session owns this task. This command belongs to an older or different session.", "SUPERVISOR_MISMATCH");
   if (connection !== undefined && record.connection !== connection) throw failure("The supervisor is registered for another connection. Keep the original command intact.", "SUPERVISOR_MISMATCH");
   if (targetHost() !== "local" && (record.remote_transport ?? "native") !== remoteTransport()) throw failure("The supervisor belongs to a different remote transport. Keep the generated route intact.", "SUPERVISOR_MISMATCH");
-  if (record.state === "stopped") throw failure("This supervisor session has stopped. Start a new supervisor when needed.", "SUPERVISOR_STOPPED");
   if (launcherAlive(record) === false) throw failure("The supervisor launcher exited. Stop the stale session before starting another supervisor.", "SUPERVISOR_ORPHANED");
   if (sending && record.state === "paused") throw failure("Automatic intervention is paused. Observation can continue; only the user should resume intervention.", "SUPERVISOR_PAUSED");
   return record;
 }
 
+// Read-only bootstrap check shared by doctor and registration. Registration
+// repeats it under the task lock; a successful doctor does not reserve an ID.
+export async function assertSupervisorRegistration(threadInput, sessionInput, { connection, ...storage } = {}) {
+  const threadId = normalizeTaskId(threadInput), sessionId = supervisorId(sessionInput), current = await getSupervisor(threadId, storage);
+  assertNotStopped(current, sessionId);
+  await assertSessionBinding(threadId, sessionId, storage);
+  if (current?.session_id === sessionId) return assertSupervisor(threadInput, sessionId, { connection, ...storage });
+  if (current && current.state !== "stopped") throw failure("A supervisor already owns this task. Use supervise status, then stop it explicitly before replacing it.", "SUPERVISOR_CONFLICT");
+  return current;
+}
+
 export async function registerSupervisor(threadInput, sessionInput, { owner = "external", launcherPid = null, connection = "shared", ...storage } = {}) {
   const threadId = normalizeTaskId(threadInput), sessionId = supervisorId(sessionInput);
   if (typeof owner !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(owner)) throw failure("Supervisor owner must be a short agent name.", "SUPERVISOR_INVALID");
   if (launcherPid !== null && (!Number.isSafeInteger(launcherPid) || launcherPid <= 0)) throw failure("Invalid supervisor launcher PID.", "SUPERVISOR_INVALID");
   if (!["shared", "desktop", "cloud", "desktop-cloud"].includes(connection)) throw failure("Invalid supervisor connection.", "SUPERVISOR_INVALID");
-  return withStoreLock(`supervisor-${threadId}`, async () => {
-    const current = await getSupervisor(threadId, storage);
-    if (current?.session_id === sessionId) {
-      if (current.connection !== connection) throw failure("The supervisor is registered for another connection. Keep the original command intact.", "SUPERVISOR_MISMATCH");
-      return assertSupervisor(threadId, sessionId, storage);
-    }
-    if (current && current.state !== "stopped") throw failure("A supervisor already owns this task. Use supervise status, then stop it explicitly before replacing it.", "SUPERVISOR_CONFLICT");
+  // Registrations take the namespace-wide lock before the task lock. Stop,
+  // pause and sends only take the task lock and never acquire in reverse order.
+  return withStoreLock("supervisor-registration", () => withStoreLock(`supervisor-${threadId}`, async () => {
+    const current = await assertSupervisorRegistration(threadId, sessionId, { connection, ...storage });
+    if (current?.session_id === sessionId) return current;
     const now = new Date().toISOString();
     const record = { schema: 1, thread_id: threadId, session_id: sessionId, owner, launcher_pid: launcherPid, connection,
-      state: "active", registered_at: now, updated_at: now, last_delivery: null };
+      state: "active", stopped_session_ids: stoppedSessionIds(current), registered_at: now, updated_at: now, last_delivery: null };
     await writeRecord(supervisorBucket(threadId), threadId, record, storage);
     return record;
-  }, storage);
+  }, storage), storage);
 }
 
 export async function controlSupervisor(threadInput, action, { expectedSession, ...storage } = {}) {
@@ -76,23 +109,32 @@ export async function controlSupervisor(threadInput, action, { expectedSession,
     if (record.state === "stopped" && action !== "stop") throw failure("A stopped supervisor cannot be resumed. Start a new supervisor.", "SUPERVISOR_STOPPED");
     if (action === "resume") await assertSupervisor(threadId, record.session_id, storage);
     const updated = { ...record, state: { pause: "paused", resume: "active", stop: "stopped" }[action], updated_at: new Date().toISOString() };
+    updated.stopped_session_ids = stoppedSessionIds(updated);
     await writeRecord(supervisorBucket(threadId), threadId, updated, storage);
     return updated;
   }, storage);
 }
 
-export async function supervisorStatus(threadInput, storage = {}) {
+export async function supervisorStatus(threadInput, { allowObservationConflict = false, ...storage } = {}) {
   const threadId = normalizeTaskId(threadInput), record = await getSupervisor(threadId, storage);
   if (!record) return { thread_id: threadId, state: "unregistered", observation: null };
-  const observation = await readRecord("supervisor-observations", record.session_id, storage);
+  let observation = await readRecord("supervisor-observations", record.session_id, storage), observationError;
+  if (allowObservationConflict && observation?.schema === 1 && observation.session_id === record.session_id && observation.thread_id !== threadId) {
+    observationError = { code: "SUPERVISOR_INVALID", message: "The observation belongs to another task.", thread_id: observation.thread_id };
+    observation = null;
+  }
   if (observation && (observation.schema !== 1 || observation.thread_id !== threadId || observation.session_id !== record.session_id)) throw failure("Invalid supervisor observation record.", "SUPERVISOR_INVALID");
-  return { ...record, launcher_alive: launcherAlive(record),
+  return { ...record, launcher_alive: launcherAlive(record), ...(observationError ? { observation_error: observationError } : {}),
     observation, observation_age_ms: observation?.last_observed_at ? Math.max(0, Date.now() - Date.parse(observation.last_observed_at)) : null };
 }
 
 export async function listSupervisors(storage = {}) {
-  const records = (await Promise.all([listRecords("supervisors", storage), listRecords("cloud-supervisors", storage)])).flat();
-  return Promise.all(records.filter(Boolean).map(record => supervisorStatus(record.thread_id, storage)));
+  const records = await supervisorRecords(storage);
+  return Promise.all(records.map(async record => {
+    const status = await supervisorStatus(record.thread_id, { ...storage, allowObservationConflict: true });
+    const conflicts = records.filter(other => other.session_id === record.session_id).map(other => other.thread_id);
+    return conflicts.length > 1 ? { ...status, session_conflict: { thread_ids: conflicts.sort() } } : status;
+  }));
 }
 
 // Observation has its own record so a concurrent read never overwrites pause/stop.