throughline 0.16.26 → 0.16.28

package/src/cli/auto-handoff.mjs

@@ -5,7 +5,8 @@ import { getDb, openReadOnlyDb, DB_PATH, CURRENT_VERSION } from '../db.mjs';
 import { listAutoHandoffs, getAutoHandoff } from '../codex-auto-handoff-store.mjs';
 import { renderFrozenDetail } from '../codex-auto-handoff-memory.mjs';
 import { readAutoHandoffConfig, writeAutoHandoffConfig } from '../codex-auto-handoff-config.mjs';
-import { autoHandoffDeliveryProfile, runAutoHandoffWorker, markAutoHandoffSources, resolveAutoHandoffSuccessor } from '../codex-auto-handoff.mjs';
+import { autoHandoffDeliveryProfile, runAutoHandoffWorker, markAutoHandoffSources, resolveAutoHandoffSuccessor,
+  settleAutoHandoffSourceGoal } from '../codex-auto-handoff.mjs';
 import { installCodexAutoHandoffHook, installClaudeAutoHandoffHooks, removeClaudeAutoHandoffHooks,
   claudeAutoHandoffHooksRegistered } from './install.mjs';
 import { sameProjectPath } from '../project-path.mjs';
@@ -19,9 +20,9 @@ const CLAUDE_ACTIONS = ['enable', 'disable', 'status', 'worker', 'desktop-open',
 
 export function parseAutoHandoffArgs(args) {
   const out = { action: args[0] ?? 'status', host: 'codex', operation: null, project: null, origin: null, turn: null, database: null, thread: null, json: false, dryRun: false };
-  if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker', 'desktop-open', 'mark-sources', 'successor'].includes(out.action)) throw Error('auto_handoff_action_invalid');
+  if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker', 'desktop-open', 'mark-sources', 'successor', 'settle-goal'].includes(out.action)) throw Error('auto_handoff_action_invalid');
   const allowed = ['host', ...{ enable: ['project'], disable: [], status: ['project', 'operation'],
-    resume: ['operation'], worker: ['operation'], 'desktop-open': ['operation'], 'mark-sources': [], successor: ['thread'], detail: ['operation', 'origin', 'turn', 'database'] }[out.action]];
+    resume: ['operation'], worker: ['operation'], 'desktop-open': ['operation'], 'mark-sources': [], successor: ['thread'], 'settle-goal': ['operation', 'thread'], detail: ['operation', 'origin', 'turn', 'database'] }[out.action]];
   const seen = new Set();
   for (let i = 1; i < args.length; i++) {
     if (seen.has(args[i])) throw Error('auto_handoff_argument_invalid');
@@ -36,8 +37,8 @@ export function parseAutoHandoffArgs(args) {
   if (out.host === 'claude' ? !CLAUDE_ACTIONS.includes(out.action) : out.action === 'desktop-open') throw Error('auto_handoff_action_unsupported');
   if (out.project && !isAbsolute(out.project)) out.project = resolve(out.project);
   if (out.project && out.operation) throw Error('auto_handoff_argument_invalid');
-  if (['worker', 'resume', 'detail', 'desktop-open'].includes(out.action) && !out.operation) throw Error('auto_handoff_operation_required');
-  if (out.action === 'successor' && !out.thread) throw Error('auto_handoff_thread_required');
+  if (['worker', 'resume', 'detail', 'desktop-open', 'settle-goal'].includes(out.action) && !out.operation) throw Error('auto_handoff_operation_required');
+  if (['successor', 'settle-goal'].includes(out.action) && !out.thread) throw Error('auto_handoff_thread_required');
   if (out.action === 'detail') {
     out.turn = Number(out.turn);
     if (!out.origin || !Number.isSafeInteger(out.turn) || out.turn < 1) throw Error('auto_handoff_detail_identity_required');
@@ -146,6 +147,9 @@ export async function run(args = []) {
       // 0.16.9 までの版が引き継いだ分の名前を付け直す（名前の無い後継へ名前、旧タスクへ引き継ぎ済みの印）。何度流しても同じ結果になる。
       const db = getDb();
       result = { status: 'ok', dry_run: parsed.dryRun, ...await markAutoHandoffSources(db, { dryRun: parsed.dryRun }) };
+    } else if (parsed.action === 'settle-goal') {
+      // 引き継ぎ済みの旧タスクに動いたまま残ったゴールを止めて、今の後継へ運ぶ（hook が起こす。ADR 0059）。
+      result = await settleAutoHandoffSourceGoal(getDb(), { operationId: parsed.operation, threadId: parsed.thread });
     } else if (parsed.action === 'worker') {
       result = publicOperation(await runAutoHandoffWorker(parsed.operation));
     } else if (parsed.action === 'resume') {

package/src/cli/grok-continue.test.mjs

@@ -1,9 +1,9 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import {
@@ -141,7 +141,7 @@ test('missing grok binary does not spawn', () => {
   assert.equal(spawned.length, 0);
 });
 
-test('successful continue spawn uses source project cwd and waits', () => {
+test('successful continue spawn uses source project cwd and waits', (t) => {
   const io = capture();
   const spawned = [];
   const uuid = '22222222-2222-4222-8222-222222222222';
@@ -164,6 +164,7 @@ test('successful continue spawn uses source project cwd and waits', () => {
   assert.equal(spawned.length, 1);
   assert.equal(io.out, `grok:${uuid}\n`);
   const { grokArgv, launchFile, cwd } = spawned[0];
+  t.after(() => rmSync(dirname(launchFile), { recursive: true, force: true }));
   assert.equal(cwd, REPO_ROOT);
   assert.equal(grokArgv.includes('--rules'), false);
   assert.ok(grokArgv.at(-1).includes(CONTEXT));
@@ -232,7 +233,11 @@ test('bin usage error is exit 2 without spawning a real grok', () => {
   const result = spawnSync(process.execPath, [BIN_PATH, 'grok-continue'], {
     cwd: REPO_ROOT,
     encoding: 'utf8',
-    env: { ...process.env, HOME: join(tmpdir(), 'tl-grok-continue-missing-home') },
+    env: {
+      ...process.env,
+      HOME: join(tmpdir(), 'tl-grok-continue-missing-home'),
+      USERPROFILE: join(tmpdir(), 'tl-grok-continue-missing-home'),
+    },
   });
   assert.equal(result.status, 2);
   assert.match(result.stderr, /Usage: throughline grok-continue --session <id>/);

package/src/cli/runtime-errors.test.mjs

@@ -1,9 +1,8 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { testTempDir } from '../test-temp-dir.mjs';
 import { fileURLToPath } from 'node:url';
 
 import { parseArgs, run } from './runtime-errors.mjs';
@@ -43,7 +42,7 @@ test('runtime-errors CLI: internal failure is fixed and does not reflect excepti
 });
 
 test('runtime-errors CLI: snapshot and diagnostics are JSON-only and contain no state path', () => {
-  const root = mkdtempSync(join(tmpdir(), 'throughline-runtime-cli-'));
+  const root = testTempDir('throughline-runtime-cli-');
   const env = {
     ...process.env,
     HOME: root,

package/src/codex-auto-handoff.mjs

@@ -1,4 +1,4 @@
-import { mkdirSync, openSync, closeSync, writeFileSync, appendFileSync, realpathSync } from 'node:fs';
+import { mkdirSync, openSync, closeSync, writeFileSync, appendFileSync, realpathSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve, relative, isAbsolute } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -73,6 +73,30 @@ export async function launchAutoHandoffWorker(id, { resume = false } = {}) {
   } finally { closeSync(log); }
 }
 
+// 同じ旧タスクのゴールを確かめる process を起こす間隔。ゴールの続行は1〜2秒おきに来るので、来るたびには起こさない。
+const GOAL_SETTLE_INTERVAL_MS = 30_000;
+
+/**
+ * 引き継ぎ済みの旧タスクにゴールが動いたまま残っていないかを、別の process に確かめさせる（hook は待たない）。
+ * 同じ旧タスクへは GOAL_SETTLE_INTERVAL_MS に1回まで。
+ * @returns {Promise<boolean>} 起こしたか
+ */
+export async function launchAutoHandoffGoalSettle(threadId, operation, { now = Date.now(), spawn = spawnPortable } = {}) {
+  const dir = join(stateRoot(), 'goal-settle');
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const marker = join(dir, threadId);
+  try { if (now - statSync(marker).mtimeMs < GOAL_SETTLE_INTERVAL_MS) return false; } catch { /* まだ1回も起こしていない */ }
+  writeFileSync(marker, '', { mode: 0o600 });
+  const log = openSync(join(stateRoot(), `${operation.handoff_id}.log`), 'a', 0o600);
+  try {
+    const child = spawn(process.execPath, [CLI_PATH, 'auto-handoff', 'settle-goal', '--operation', operation.handoff_id,
+      '--thread', threadId, '--json'], { detached: true, stdio: ['ignore', log, log], windowsHide: true });
+    await new Promise((resolveSpawn, reject) => { child.once('spawn', resolveSpawn); child.once('error', reject); });
+    child.unref();
+    return true;
+  } finally { closeSync(log); }
+}
+
 function liveSuccessors(db, threadId, options, seen) {
   const found = [];
   for (const operation of listDeliveredAutoHandoffsForSource(db, threadId)) {
@@ -144,6 +168,12 @@ function recordAutoHandoffRedirect(entry) {
   appendFileSync(join(stateRoot(), 'redirects.jsonl'), JSON.stringify(entry) + '\n', { mode: 0o600 });
 }
 
+/** 引き継ぎ済みの旧タスクに残っていたゴールを片付けた記録。会話の本文も、ゴールの目標の文も書かない。 */
+function recordGoalSettle(entry) {
+  mkdirSync(stateRoot(), { recursive: true, mode: 0o700 });
+  appendFileSync(join(stateRoot(), 'goal-settles.jsonl'), JSON.stringify(entry) + '\n', { mode: 0o600 });
+}
+
 // workerを起動してから、workerが自分のprocessを記録へ名乗るまでの間。この間の引き継ぎは、進んでいる物として扱う。
 const WORKER_START_GRACE_MS = 15_000;
 // workerが1回の引き継ぎに掛ける時間の上限（各段の待ち時間の合計より長い）。process一覧を読めない時だけ使う。
@@ -192,6 +222,7 @@ function settleUndeliveredAutoHandoff(db, threadId, { rolloutPath, processes, re
 export async function requestCodexAutoHandoff({ payload, db = null,
   config = readAutoHandoffConfig(), launchWorker = launchAutoHandoffWorker,
   findThread = findCodexThreadCandidate, openThread = openSuccessor, recordRedirect = recordAutoHandoffRedirect,
+  settleGoal = launchAutoHandoffGoalSettle,
   recordInternalCompaction = recordInternalCompactionStop, recordUnrecordedCompaction = recordUnrecordedCompactionPass,
   processes = readRuntimeProcesses, readTarget = targetState, now = Date.now() } = {}) {
   if (payload.trigger !== 'auto' || !autoHandoffEnabledFor(config, payload.cwd)) return { status: 'skipped' };
@@ -229,9 +260,16 @@ export async function requestCodexAutoHandoff({ payload, db = null,
   const sameTurn = findAutoHandoffForTurn(actualDb, threadId, turnId);
   const successor = sameTurn ? null : findLiveAutoHandoffSuccessor(actualDb, threadId, { findThread });
   if (successor) {
-    const opened = openThread(successor);
+    // Codex が自分で起こしたターン（ゴールの続行など）では、後継を開かない。人が入力していないのに、画面が後継へ
+    // 切り替わり続ける（2026-10-13、Windows。旧タスクに残ったゴールが1〜2秒おきにターンを起こし、約2,000回）。
+    const internal = state.internalInputOnly === true;
+    const opened = internal ? false : openThread(successor);
+    // 旧タスクにゴールが動いたまま残っていると、止めてもすぐ次のターンが来る。別の process で止めて、後継へ運ぶ (ADR 0059)。
+    let goalSettle = false;
+    try { goalSettle = await settleGoal(threadId, successor, { now }); } catch { /* 起こせなくても、このターンは止める */ }
     recordRedirect({ at: new Date().toISOString(), source_thread_id: threadId, source_turn_id: turnId,
-      handoff_id: successor.handoff_id, target_thread_id: successor.target_thread_id, opened });
+      handoff_id: successor.handoff_id, target_thread_id: successor.target_thread_id, opened,
+      ...(internal ? { internal: true } : {}), ...(goalSettle ? { goal_settle: true } : {}) });
     return { status: 'ok', operationId: successor.handoff_id, inserted: false, redirected: true,
       targetThreadId: successor.target_thread_id, opened, continue: false,
       stopReason: `このタスクはThroughlineが新しいタスクへ引き継ぎ済みです（引き継ぎID: ${successor.handoff_id}）。` +
@@ -446,6 +484,88 @@ export async function carryAutoHandoffQueue(db, operation, runtime, { connect =
   return summary();
 }
 
+// Codex のゴール（`/goal`。目標が終わるまで、タスクが手すきになるたびに Codex が自分で次のターンを起こす）のうち、
+// 後継へ運ぶ状態。動いている物と、利用者が止めている物だけ。完了した物と、Codex が上限や行き詰まりで止めた物は運ばない。
+const CARRIED_GOAL_STATUSES = new Set(['active', 'paused']);
+
+/**
+ * 旧タスクのゴールを一時停止にする。動いたままのゴールは、hook が止めたターンの直後から、Codex が次のターンを
+ * 起こし続ける。ゴールは消さない（後継へ運ぶ元にする。旧タスクで続けたい時は、利用者が再開できる）。
+ * ゴールを扱えなくても引き継ぎは止めない（理由は worker のログに残す）。
+ * @returns {Promise<'paused'|'idle'|'none'|'failed'>} idle は動いていないゴールがある、none はゴールが無い
+ */
+export async function pauseAutoHandoffSourceGoal(operation, runtime, { connect = withCodexReceiver } = {}) {
+  const threadId = operation.source_thread_id;
+  try {
+    return await connect(autoHandoffDeliveryProfile, { thread_id: threadId, codex_home: operation.codex_home }, async request => {
+      const goal = (await request('thread/goal/get', { threadId })).goal;
+      if (!goal) return 'none';
+      if (goal.status !== 'active') return 'idle';
+      await request('thread/goal/set', { threadId, status: 'paused' });
+      return 'paused';
+    }, runtime);
+  } catch (cause) {
+    process.stderr.write(`[auto-handoff] source goal pause failed: ${cause?.delivery_code ?? cause?.code ?? 'unknown'}\n`);
+    return 'failed';
+  }
+}
+
+/**
+ * 旧タスクのゴールを後継へ運ぶ。目標の文と、予算の残りを写す。旧タスクで動いていたゴールは後継でも動かし、
+ * 利用者が止めていたゴールは止めたまま運ぶ。後継にもうゴールがあれば書き換えない。旧タスクのゴールは消さない。
+ * 運べなくても引き継ぎは止めない（後継はもう作業を続けている。理由は worker のログに残す）。
+ * @param {{wasActive?: boolean, onlyActive?: boolean, sourceThreadId?: string}} [options] wasActive は、引き継ぎの初めに
+ *   この製品が一時停止にしたゴール（後継では動かす）。onlyActive は、今も動いているゴールだけを運ぶ（止まっている物には触らない）。
+ * @returns {Promise<'active'|'paused'|'kept'|'none'|'failed'>} active・paused は後継へ付けた状態、kept は後継にもうゴールがある
+ */
+export async function carryAutoHandoffGoal(operation, runtime, { connect = withCodexReceiver, wasActive = false,
+  onlyActive = false, sourceThreadId = operation.source_thread_id } = {}) {
+  const targetId = operation.target_thread_id;
+  try {
+    return await connect(autoHandoffDeliveryProfile, { thread_id: sourceThreadId, codex_home: operation.codex_home }, async request => {
+      const goal = (await request('thread/goal/get', { threadId: sourceThreadId })).goal;
+      if (!goal || !CARRIED_GOAL_STATUSES.has(goal.status) || typeof goal.objective !== 'string') return 'none';
+      let active = wasActive;
+      if (goal.status === 'active') {
+        // 初めの一時停止が効かなかった、または引き継いだ後で動き出した。旧タスクを先に止める。
+        await request('thread/goal/set', { threadId: sourceThreadId, status: 'paused' });
+        active = true;
+      } else if (onlyActive) return 'none';
+      if ((await request('thread/goal/get', { threadId: targetId })).goal) return 'kept';
+      const status = active ? 'active' : 'paused';
+      // 予算は、旧タスクで使った分を引いた残りを渡す（使い切ったゴールは Codex が budgetLimited にするので、ここへ来ない）。
+      const budget = Number.isSafeInteger(goal.tokenBudget)
+        ? Math.max(1, goal.tokenBudget - (Number.isSafeInteger(goal.tokensUsed) ? goal.tokensUsed : 0)) : null;
+      await request('thread/goal/set', { threadId: targetId, objective: goal.objective, status,
+        ...(budget == null ? {} : { tokenBudget: budget }) });
+      return status;
+    }, runtime);
+  } catch (cause) {
+    process.stderr.write(`[auto-handoff] goal carry failed: ${cause?.delivery_code ?? cause?.code ?? 'unknown'}\n`);
+    return 'failed';
+  }
+}
+
+/**
+ * 引き継ぎ済みの旧タスクにゴールが動いたまま残っていた時の片付け（hook が起こす）。旧タスクのゴールを一時停止にし、
+ * 今の後継にゴールが無ければ運ぶ。0.16.27 までの版が引き継いだ旧タスクと、引き継いだ後で利用者が再開したゴールが当たる。
+ * @returns {Promise<{status: 'settled'|'skipped', goal?: string, reason?: string}>}
+ */
+export async function settleAutoHandoffSourceGoal(db, { operationId, threadId }, { executable = () => platformDesktopFinder()(),
+  carryGoal = carryAutoHandoffGoal, findThread = findCodexThreadCandidate, record = recordGoalSettle } = {}) {
+  if (!CODEX_NATIVE_ID_PATTERN.test(threadId ?? '')) throw error('handoff_thread_id_invalid');
+  // 起こされてからここまでの間に、後継がさらに引き継いでいる事がある。今の一番先の後継へ運ぶ。
+  const successor = findLiveAutoHandoffSuccessor(db, threadId, { findThread });
+  if (!successor || !getAutoHandoff(db, operationId)) return { status: 'skipped', reason: 'handoff_successor_unavailable' };
+  const goal = await carryGoal(successor, { executable: executable(), timeout_ms: 30_000 }, { sourceThreadId: threadId, onlyActive: true });
+  if (goal !== 'none') {
+    record({ at: new Date().toISOString(), source_thread_id: threadId, handoff_id: successor.handoff_id,
+      target_thread_id: successor.target_thread_id, goal });
+    process.stderr.write(`[auto-handoff] goal settled: ${goal}\n`);
+  }
+  return { status: 'settled', goal };
+}
+
 // 受け取った記憶をそのまま運ぶ上限。超えた分は切り、切った事を記録する（後継の記憶に出す）。
 const INHERITED_MEMORY_MAX_CHARS = 120_000;
 
@@ -606,6 +726,7 @@ export function showAutoHandoffFailure(operation) {
 <p><a href="codex://threads/${escape(operation.source_thread_id)}">旧タスクを開く</a>${operation.target_thread_id ? ` / <a href="codex://threads/${escape(operation.target_thread_id)}">後継タスクを開く</a>` : ''}</p>
 <p>理由: <code>${escape(operation.error_code)}</code></p><p>引き継ぎID: <code>${escape(operation.handoff_id)}</code></p>
 ${operation.error_code === 'handoff_summarizer_backend_failed' ? '<p>記憶の要約に使うCodex CLIが失敗しました。通信の断、利用上限、認証切れなどで起きます。会話の記録と入力は失われていません。Codex CLIが使える様になった後、旧タスクへ入力すると、引き継ぎをもう一度始めます。</p>' : ''}
+${operation.runtime?.goalCarry?.paused ? '<p>旧タスクのゴール（/goal）は、同じターンが繰り返されない様に一時停止にしてあります。引き継ぎを再開して後継が動けば、ゴールは後継へ運ばれます。旧タスクのまま続ける時は、旧タスクでゴールを再開してください。</p>' : ''}
 <p>状態: ${escape(operation.state)} / 停止した工程: ${escape(operation.resume_state)}</p>
 <p>確認: <code>throughline auto-handoff status --operation ${escape(operation.handoff_id)}</code></p>
 <p>原因を解消した後の再開: <code>throughline auto-handoff resume --operation ${escape(operation.handoff_id)}</code></p>
@@ -618,7 +739,7 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
   const deps = { processes: readRuntimeProcesses, readSource: sourceState,
     nativeState: sourceNativeState, capture: captureCodexRolloutToDb, summaries: ensureAutoHandoffSummaries,
     createTarget, readTarget: targetState, openTarget, verify: verifyCodexParent, markSource: markAutoHandoffSource,
-    carryQueue: carryAutoHandoffQueue,
+    carryQueue: carryAutoHandoffQueue, pauseGoal: pauseAutoHandoffSourceGoal, carryGoal: carryAutoHandoffGoal,
     submit: submitCodexParentAnswer, notify: showAutoHandoffFailure, wait: waitForHandoff,
     executable: () => platformDesktopFinder()(), liveSuccessor: findLiveAutoHandoffSuccessor, ...dependencies };
   let operation = getAutoHandoff(db, id);
@@ -644,6 +765,13 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
       throw error('handoff_mutation_outcome_unknown');
     }
     const runtime = { executable: deps.executable(), timeout_ms: 30_000 };
+    // 旧タスクのゴールを先に止める。動いたままだと、止めたターンの直後から Codex が次のターンを起こし続ける。
+    // 同じ旧タスクの前の引き継ぎ（途中で止まった物）が止めていたゴールは、動いていた物として後継へ運ぶ (ADR 0059)。
+    if (!operation.runtime?.goalCarry) {
+      const paused = await deps.pauseGoal(operation, runtime) === 'paused' ||
+        listUndeliveredAutoHandoffsForSource(db, operation.source_thread_id).some(other => other.runtime?.goalCarry?.paused);
+      update({ runtime_json: { ...(operation.runtime ?? {}), goalCarry: { paused } } });
+    }
     if (operation.state === 'requested') {
       const state = await deps.wait(() => {
         const state = deps.readSource(operation);
@@ -663,7 +791,7 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
       }
       const native = await deps.nativeState(operation, runtime);
       update({ state: 'source_stopped', settings_json: state.settings,
-        runtime_json: { ...native, databasePath: DB_PATH, ...(inheritedMemory ? { inheritedMemory } : {}) } });
+        runtime_json: { ...(operation.runtime ?? {}), ...native, databasePath: DB_PATH, ...(inheritedMemory ? { inheritedMemory } : {}) } });
     }
     // 最中に来た入力のturnが止まり切るまでの間は、境界がまだ見えない。短く待ってから判定する。
     const confirmSourceBoundary = () => deps.wait(() => sourceBoundary(operation, deps.readSource(operation)) || null,
@@ -737,6 +865,10 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
         return target.correlatedTurnId && target.progress ? target : null;
       }, { timeoutMs: 180_000, timeoutCode: 'handoff_target_progress_unconfirmed' });
       update({ state: 'continued', started_turn_id: target.correlatedTurnId, resume_state: null, error_code: null });
+      // 旧タスクのゴールを後継へ運ぶ。後継の最初のターンが動いている間に付けると、そのターンの後から Codex が続ける。
+      const goal = await deps.carryGoal(operation, runtime, { wasActive: operation.runtime?.goalCarry?.paused === true });
+      update({ runtime_json: { ...(getAutoHandoff(db, id).runtime ?? {}), goalCarry: { ...(operation.runtime?.goalCarry ?? {}), carried: goal } } });
+      if (goal !== 'none') globalThis.process.stderr.write(`[auto-handoff] goal carried: ${goal}\n`);
       // 旧タスクの順番待ちに残った入力を後継へ運ぶ。後継の最初のターン（継続の指示）が始まった後なので、順番は変わらない。
       await deps.carryQueue(db, operation, runtime);
       // 後継が作業を続けたのを確かめてから付ける。途中で止まった引き継ぎの旧タスクには付けない。

package/src/codex-auto-handoff.test.mjs

@@ -7,6 +7,8 @@ import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { EventEmitter } from 'node:events';
+import { testTempDir } from './test-temp-dir.mjs';
 import { requestAutoHandoff, updateAutoHandoff, getAutoHandoff, freezeCodexMemory,
   claimAutoHandoff, continuationInput } from './codex-auto-handoff-store.mjs';
 import { collectAutoHandoffMemory, ensureAutoHandoffSummaries, renderAutoHandoffMemory,
@@ -15,7 +17,8 @@ import { readCodexHandoffState, settingsMatch, threadStartSettings, resolvePrepa
 import { runAutoHandoffWorker, requestCodexAutoHandoff, sourceBoundary,
   autoHandoffTargetName, nameAutoHandoffTarget, findLiveAutoHandoffSuccessor,
   markAutoHandoffSource, markAutoHandoffSources, autoHandoffSourceFallbackTitle, carryAutoHandoffQueue,
-  untrackedInheritedMemory, resolveAutoHandoffSuccessor, hookIdentityShape } from './codex-auto-handoff.mjs';
+  untrackedInheritedMemory, resolveAutoHandoffSuccessor, hookIdentityShape,
+  pauseAutoHandoffSourceGoal, carryAutoHandoffGoal, settleAutoHandoffSourceGoal, launchAutoHandoffGoalSettle } from './codex-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
 async function withDb(fn) {
@@ -117,6 +120,10 @@ function workerDependencies(db, settings, submit, counters) {
     readTarget: operation => ({ settings, latestTurnId: ['submitted', 'unknown'].includes(operation.state) ? 'new-turn' : null,
       correlatedTurnId: ['submitted', 'unknown'].includes(operation.state) ? 'new-turn' : null, progress: true }),
     openTarget: () => {}, verify: async () => {}, submit,
+    pauseGoal: async operation => { (counters.goal ??= []).push(`pause:${operation.state}`); return counters.goalPause ?? 'none'; },
+    carryGoal: async (operation, runtime, options) => {
+      (counters.goal ??= []).push(`carry:${operation.state}:${options.wasActive}`); return counters.goalCarry ?? 'none';
+    },
     carryQueue: async (db, operation) => { (counters.carried ??= []).push(`${operation.source_thread_id}:${operation.state}`); return { moved: 0, unknown: 0, left: 0 }; },
     markSource: async (operation, runtime, options) => {
       (counters.marked ??= []).push(`${operation.source_thread_id}:${operation.state}`);
@@ -193,7 +200,7 @@ test('実行中の子がある時は後継を作らない', async () => withDb(a
 }));
 
 test('rollout の developer 記憶から、受け取った Throughline の記憶の本文を最初の1つだけ読む', () => {
-  const dir = mkdtempSync(join(tmpdir(), 'tl-inherited-'));
+  const dir = testTempDir('tl-inherited-');
   const file = join(dir, 'rollout.jsonl');
   const developer = text => ({ type: 'response_item', payload: { type: 'message', role: 'developer', content: [{ type: 'input_text', text }] } });
   const rows = [{ type: 'session_meta', payload: { id: 'T', cwd: '/project', originator: 'Codex Desktop', source: 'vscode' } },
@@ -445,7 +452,7 @@ test('引き継ぎ済みの旧タスクへ新しい入力が来ても後継を
   const payload = desktopSource(home, thread, '33333333-3333-3333-3333-333333333333');
   const config = { enabled: true, projects: [home], openHost: 'desktop' };
   const seen = { launched: 0, opened: [], recorded: [], asked: [] };
-  const args = { db, config, payload, launchWorker: async () => { seen.launched++; },
+  const args = { db, config, payload, launchWorker: async () => { seen.launched++; }, settleGoal: async () => false,
     findThread: query => { seen.asked.push(query); return { mtimeMs: 1 }; },
     openThread: operation => { seen.opened.push(operation.target_thread_id); return true; },
     recordRedirect: entry => { seen.recorded.push(entry); } };
@@ -1025,3 +1032,248 @@ test('要約のbackendが使えない時、workerは固定の理由で止まり
     assert.equal(counters.carried, undefined, '途中で止まった引き継ぎでは、順番待ちを動かさない');
   }
 }));
+
+// Codex のゴールの口の代わり。goals は thread id ごとの今のゴール（無ければ null）。
+function goalReceiver(goals, sent, fail = null) {
+  return async (profile, parent, action) => action(async (method, params) => {
+    sent.push([method, params]);
+    if (method === fail) throw Object.assign(new Error('rejected'), { delivery_code: 'CODEX_RECEIVER_REJECTED' });
+    if (method === 'thread/goal/get') return { goal: goals[params.threadId] ?? null };
+    if (method === 'thread/goal/set') {
+      const { threadId, ...fields } = params;
+      goals[threadId] = { tokenBudget: null, tokensUsed: 0, ...(goals[threadId] ?? {}), ...fields };
+      return { goal: goals[threadId] };
+    }
+    throw new Error(`想定していない要求: ${method}`);
+  });
+}
+
+test('旧タスクの動いているゴールを一時停止にし、止まっているゴールと無いゴールには触らない。扱えなくても引き継ぎは止めない', async () => {
+  const operation = { source_thread_id: 'S', codex_home: '/home' };
+  let sent = []; let goals = { S: { status: 'active', objective: '目標' } };
+  assert.equal(await pauseAutoHandoffSourceGoal(operation, {}, { connect: goalReceiver(goals, sent) }), 'paused');
+  assert.deepEqual(sent, [['thread/goal/get', { threadId: 'S' }], ['thread/goal/set', { threadId: 'S', status: 'paused' }]]);
+  assert.equal(goals.S.objective, '目標', '目標の文は消さない');
+
+  for (const [goal, expected] of [[null, 'none'], [{ status: 'paused', objective: '目標' }, 'idle'], [{ status: 'complete', objective: '目標' }, 'idle']]) {
+    sent = [];
+    assert.equal(await pauseAutoHandoffSourceGoal(operation, {}, { connect: goalReceiver({ S: goal }, sent) }), expected);
+    assert.equal(sent.length, 1, '読むだけ');
+  }
+  // ゴールの口が無い版の Codex、口が断った時。
+  assert.equal(await pauseAutoHandoffSourceGoal(operation, {}, { connect: goalReceiver({}, [], 'thread/goal/get') }), 'failed');
+  assert.equal(await pauseAutoHandoffSourceGoal(operation, {}, { connect: goalReceiver({ S: { status: 'active', objective: 'x' } }, [], 'thread/goal/set') }), 'failed');
+});
+
+test('旧タスクのゴールを後継へ運ぶ。動いていた物は動かし、利用者が止めていた物は止めたまま運び、予算は残りを渡す', async () => {
+  const operation = { source_thread_id: 'S', target_thread_id: 'T', codex_home: '/home' };
+  // この製品が引き継ぎの初めに止めたゴール。後継では動かす。旧タスクのゴールは止めたまま残す。
+  let goals = { S: { status: 'paused', objective: '目標', tokenBudget: 1000, tokensUsed: 300 } }; let sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent), wasActive: true }), 'active');
+  assert.deepEqual(sent.at(-1), ['thread/goal/set', { threadId: 'T', objective: '目標', status: 'active', tokenBudget: 700 }]);
+  assert.equal(goals.S.status, 'paused'); assert.equal(goals.S.objective, '目標');
+
+  // 利用者が止めていたゴール。止めたまま運ぶ。予算の無いゴールは、予算を付けない。
+  goals = { S: { status: 'paused', objective: '目標', tokenBudget: null, tokensUsed: 300 } }; sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent) }), 'paused');
+  assert.deepEqual(sent.at(-1), ['thread/goal/set', { threadId: 'T', objective: '目標', status: 'paused' }]);
+
+  // 初めの一時停止が効いていなかった時は、ここで旧タスクを先に止めてから、後継で動かす。
+  goals = { S: { status: 'active', objective: '目標' } }; sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent) }), 'active');
+  assert.deepEqual(sent.map(([method, params]) => `${method}:${params.threadId}:${params.status ?? ''}`),
+    ['thread/goal/get:S:', 'thread/goal/set:S:paused', 'thread/goal/get:T:', 'thread/goal/set:T:active']);
+
+  // 後継にもうゴールがある時は書き換えない。
+  goals = { S: { status: 'paused', objective: '目標' }, T: { status: 'active', objective: '別の目標' } }; sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent), wasActive: true }), 'kept');
+  assert.equal(goals.T.objective, '別の目標'); assert.ok(!sent.some(([method]) => method === 'thread/goal/set'));
+
+  // ゴールが無い、完了した、Codex が上限や行き詰まりで止めた。運ばない。
+  for (const goal of [null, { status: 'complete', objective: '目標' }, { status: 'budgetLimited', objective: '目標' },
+    { status: 'usageLimited', objective: '目標' }, { status: 'blocked', objective: '目標' }]) {
+    sent = [];
+    assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver({ S: goal }, sent), wasActive: true }), 'none');
+    assert.equal(sent.length, 1, '読むだけ');
+  }
+  // 今も動いているゴールだけを運ぶ指定では、止まっているゴールに触らない。
+  goals = { S: { status: 'paused', objective: '目標' } }; sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent), onlyActive: true }), 'none');
+  assert.equal(sent.length, 1); assert.equal(goals.T, undefined);
+  // 別の旧タスク（後継のさらに前のタスク）を指定できる。
+  goals = { OLD: { status: 'active', objective: '目標' } }; sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent), onlyActive: true, sourceThreadId: 'OLD' }), 'active');
+  assert.equal(goals.OLD.status, 'paused'); assert.equal(goals.T.status, 'active');
+  // 運べなくても例外にしない。
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver({ S: { status: 'paused', objective: 'x' } }, [], 'thread/goal/set') }), 'failed');
+});
+
+// 1つのDBで何度も引き継ぐ試験では、後継のIDを旧タスクごとに変える（後継のIDは一意）。
+function uniqueTarget(deps, source) {
+  const createTarget = deps.createTarget;
+  deps.createTarget = async (db, operation) => {
+    await createTarget(db, operation);
+    updateAutoHandoff(db, operation.handoff_id, { target_thread_id: `target-${source}` });
+  };
+}
+
+test('workerは、最初に旧タスクのゴールを止め、後継が作業を続けた後でゴールを運ぶ。順番待ちを運ぶより先', async () => withDb(async db => {
+  const run = async (source, counters, before = () => {}) => {
+    const operation = request(db, source, { now: 1 }).operation;
+    before(operation);
+    const deps = workerDependencies(db, {}, async () => ({ queued_submission_id: 'receipt' }), counters);
+    uniqueTarget(deps, source);
+    const order = []; const carryQueue = deps.carryQueue, carryGoal = deps.carryGoal;
+    deps.carryQueue = async (...args) => { order.push('queue'); return carryQueue(...args); };
+    deps.carryGoal = async (...args) => { order.push('goal'); return carryGoal(...args); };
+    return { result: await runAutoHandoffWorker(operation.handoff_id, { db, dependencies: deps }), order };
+  };
+  // 動いているゴールがあった。
+  let counters = { created: 0, notified: 0, goalPause: 'paused', goalCarry: 'active' };
+  let { result, order } = await run('goal-active', counters);
+  assert.equal(result.state, 'continued');
+  assert.deepEqual(counters.goal, ['pause:requested', 'carry:continued:true']);
+  assert.deepEqual(order, ['goal', 'queue']);
+  assert.deepEqual(getAutoHandoff(db, result.handoff_id).runtime.goalCarry, { paused: true, carried: 'active' });
+  assert.equal(getAutoHandoff(db, result.handoff_id).runtime.targetPrepared, true, 'ゴールの記録で、ほかの記録を消さない');
+
+  // ゴールが無い・扱えない時も引き継ぎは進む。
+  for (const [index, goalPause] of ['none', 'idle', 'failed'].entries()) {
+    counters = { created: 0, notified: 0, goalPause, goalCarry: goalPause === 'idle' ? 'paused' : 'none' };
+    ({ result } = await run(`goal-${index}`, counters));
+    assert.equal(result.state, 'continued'); assert.equal(counters.notified, 0);
+    assert.deepEqual(counters.goal, ['pause:requested', 'carry:continued:false']);
+  }
+
+  // 途中で止まった引き継ぎをやり直す時は、ゴールをもう一度は読まず、最初に止めた事を覚えている。
+  counters = { created: 0, notified: 0, goalPause: 'paused', goalCarry: 'active' };
+  const operation = request(db, 'goal-resume', { now: 1 }).operation;
+  const deps = workerDependencies(db, {}, async () => ({ queued_submission_id: 'receipt' }), counters);
+  uniqueTarget(deps, 'goal-resume');
+  deps.summaries = () => { throw new Error('別の失敗'); };
+  const failed = await runAutoHandoffWorker(operation.handoff_id, { db, dependencies: deps });
+  assert.equal(failed.state, 'failed'); assert.deepEqual(failed.runtime.goalCarry, { paused: true });
+  assert.deepEqual(counters.goal, ['pause:requested'], '途中で止まった引き継ぎでは、ゴールを後継へ運ばない');
+  deps.summaries = () => {}; counters.goalPause = 'idle';
+  const resumed = await runAutoHandoffWorker(operation.handoff_id, { db, resume: true, dependencies: deps });
+  assert.equal(resumed.state, 'continued');
+  assert.deepEqual(counters.goal, ['pause:requested', 'carry:continued:true']);
+
+  // 同じ旧タスクの前の引き継ぎ（途中で止まった物）が止めていたゴールは、新しい引き継ぎでも動いていた物として運ぶ。
+  counters = { created: 0, notified: 0, goalPause: 'idle', goalCarry: 'active' };
+  ({ result } = await run('goal-earlier', counters, current => {
+    const earlier = requestAutoHandoff(db, { threadId: 'goal-earlier', turnId: 'earlier-turn', projectPath: '/project',
+      rolloutPath: '/codex/rollout.jsonl', codexHome: '/codex', openHost: 'desktop', now: 0 }).operation;
+    updateAutoHandoff(db, earlier.handoff_id, { state: 'failed', runtime_json: { goalCarry: { paused: true } } });
+    assert.notEqual(earlier.handoff_id, current.handoff_id);
+  }));
+  assert.deepEqual(counters.goal, ['pause:requested', 'carry:continued:true']);
+}));
+
+// Codex がゴールの続行で起こして、hook が止めたターンの実物の並び（Windows の Codex Desktop 0.162.0-alpha.17.2、2026-10-13）。
+function goalContinuation(turn, at) {
+  return [
+    { timestamp: `${at}.460Z`, type: 'event_msg', payload: { type: 'task_started', turn_id: turn } },
+    { timestamp: `${at}.782Z`, type: 'response_item', payload: { type: 'message', role: 'user',
+      content: [{ type: 'input_text', text: '<codex_internal_context source="goal">\nContinue working toward the active thread goal.\n</codex_internal_context>' }] } },
+    { timestamp: `${at}.802Z`, type: 'event_msg', payload: { type: 'turn_aborted', turn_id: turn, reason: 'interrupted' } },
+  ];
+}
+
+test('rollout から、ターンの入力が Codex 自身の文脈だけだったかを読む', async () => withDb((db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111';
+  const file = sourceRollout(home, thread, 'turn-a', [...goalContinuation('turn-goal', '2026-10-07T00:50:00'),
+    ...stoppedInput('turn-person', '2026-10-07T00:51:00')]);
+  const read = turnId => readCodexHandoffState(file, { threadId: thread, turnId }).internalInputOnly;
+  assert.equal(read('turn-goal'), true); assert.equal(read('turn-person'), false); assert.equal(read('turn-a'), false);
+  assert.equal(readCodexHandoffState(file, { threadId: thread }).internalInputOnly, false, 'turn を指定しない時は最後の turn');
+  // 入力が turn の開始より前に記録される並びでも同じ。
+  const [started, input, aborted] = goalContinuation('turn-goal-2', '2026-10-07T00:52:00');
+  const early = sourceRollout(home, '22222222-2222-2222-2222-222222222222', 'turn-a', [input, started, aborted]);
+  assert.equal(readCodexHandoffState(early, { threadId: '22222222-2222-2222-2222-222222222222', turnId: 'turn-goal-2' }).internalInputOnly, true);
+  // ターンの途中で Codex が足す環境の知らせ（日付が変わった時など）は、入力の出どころに数えない（macOS の Codex Desktop 0.162.0-alpha.17.2 の実物）。
+  const [started3, input3, aborted3] = goalContinuation('turn-goal-3', '2026-10-07T00:53:00');
+  const environment = { timestamp: '2026-10-07T00:53:00.790Z', type: 'response_item', payload: { type: 'message', role: 'user',
+    content: [{ type: 'input_text', text: '<environment_context>\n  <current_date>2026-10-08</current_date>\n</environment_context>' }] } };
+  const dated = sourceRollout(home, '33333333-3333-3333-3333-333333333333', 'turn-a', [started3, input3, environment, aborted3]);
+  assert.equal(readCodexHandoffState(dated, { threadId: '33333333-3333-3333-3333-333333333333', turnId: 'turn-goal-3' }).internalInputOnly, true);
+}));
+
+test('引き継ぎ済みの旧タスクへゴールの続行が来た時は、止めるが後継を開かず、ゴールの片付けを起こす', async () => withDb(async (db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111', turnA = '22222222-2222-2222-2222-222222222222';
+  const goalTurn = '33333333-3333-3333-3333-333333333333', personTurn = '44444444-4444-4444-4444-444444444444';
+  const first = delivered(db, home, thread, turnA, 'successor-1', 1);
+  const config = { enabled: true, projects: [home], openHost: 'desktop' };
+  const seen = { opened: [], recorded: [], settled: [] };
+  const args = { db, config, launchWorker: async () => { throw new Error('後継を増やしてはいけない'); }, findThread: () => ({ mtimeMs: 1 }),
+    openThread: operation => { seen.opened.push(operation.target_thread_id); return true; },
+    recordRedirect: entry => { seen.recorded.push(entry); },
+    settleGoal: async (threadId, operation) => { seen.settled.push([threadId, operation.handoff_id]); return seen.settled.length === 1; } };
+  const payload = (turn, later) => ({ trigger: 'auto', cwd: home, session_id: thread, turn_id: turn,
+    transcript_path: sourceRollout(home, thread, turnA, later) });
+
+  const goal = await requestCodexAutoHandoff({ ...args, payload: payload(goalTurn, goalContinuation(goalTurn, '2026-10-07T00:50:00')) });
+  assert.equal(goal.continue, false); assert.equal(goal.redirected, true); assert.equal(goal.opened, false);
+  assert.deepEqual(seen.opened, [], '人が入力していないターンでは、画面を後継へ切り替えない');
+  assert.deepEqual(seen.settled, [[thread, first.handoff_id]]);
+  assert.deepEqual({ ...seen.recorded[0], at: null }, { at: null, source_thread_id: thread, source_turn_id: goalTurn,
+    handoff_id: first.handoff_id, target_thread_id: 'successor-1', opened: false, internal: true, goal_settle: true });
+
+  // 人の入力では、今までどおり後継を開く。ゴールの片付けは、起こす側が間隔を空ける（ここでは2回めを起こさない）。
+  const person = await requestCodexAutoHandoff({ ...args, payload: payload(personTurn, stoppedInput(personTurn, '2026-10-07T00:51:00')) });
+  assert.equal(person.opened, true); assert.deepEqual(seen.opened, ['successor-1']);
+  assert.equal(seen.recorded[1].internal, undefined); assert.equal(seen.recorded[1].goal_settle, undefined);
+  // 片付けを起こせなくても、ターンは止める。
+  const broken = await requestCodexAutoHandoff({ ...args, settleGoal: async () => { throw new Error('起こせません'); },
+    payload: payload(goalTurn, goalContinuation(goalTurn, '2026-10-07T00:50:00')) });
+  assert.equal(broken.continue, false); assert.equal(broken.redirected, true);
+}));
+
+test('ゴールの片付けは、同じ旧タスクへは間隔を空けて1つだけ起こす', async () => withDb(async () => {
+  const spawned = [];
+  const spawn = (command, args, options) => {
+    spawned.push({ args, detached: options.detached });
+    const child = new EventEmitter(); child.unref = () => {}; child.pid = 1;
+    queueMicrotask(() => child.emit('spawn'));
+    return child;
+  };
+  const operation = { handoff_id: 'handoff-1' };
+  assert.equal(await launchAutoHandoffGoalSettle('thread-a', operation, { spawn }), true);
+  assert.deepEqual(spawned[0].args.slice(1), ['auto-handoff', 'settle-goal', '--operation', 'handoff-1', '--thread', 'thread-a', '--json']);
+  assert.equal(spawned[0].detached, true);
+  assert.equal(await launchAutoHandoffGoalSettle('thread-a', operation, { spawn }), false, '続けて来ても起こさない');
+  assert.equal(await launchAutoHandoffGoalSettle('thread-b', operation, { spawn }), true, '別の旧タスクは別に数える');
+  assert.equal(await launchAutoHandoffGoalSettle('thread-a', operation, { spawn, now: Date.now() + 31_000 }), true, '間隔が空けば、もう一度起こす');
+  assert.equal(spawned.length, 3);
+}));
+
+test('片付けは、旧タスクの動いているゴールを止めて、今の一番先の後継へ運び、記録を1行残す', async () => withDb(async (db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111';
+  const first = delivered(db, home, thread, 'turn-a', 'successor-1', 1);
+  const second = delivered(db, home, 'successor-1', 'turn-b', 'successor-2', 2);
+  const seen = { carried: [], recorded: [] };
+  const options = goal => ({ executable: () => '公式Desktop試験fixture', findThread: () => ({ mtimeMs: 1 }),
+    carryGoal: async (operation, runtime, carry) => { seen.carried.push([operation.handoff_id, carry, runtime.executable]); return goal; },
+    record: entry => { seen.recorded.push(entry); } });
+  const settled = await settleAutoHandoffSourceGoal(db, { operationId: first.handoff_id, threadId: thread }, options('active'));
+  assert.deepEqual(settled, { status: 'settled', goal: 'active' });
+  assert.deepEqual(seen.carried, [[second.handoff_id, { sourceThreadId: thread, onlyActive: true }, '公式Desktop試験fixture']]);
+  assert.deepEqual({ ...seen.recorded[0], at: null }, { at: null, source_thread_id: thread, handoff_id: second.handoff_id,
+    target_thread_id: 'successor-2', goal: 'active' });
+  // 動いているゴールが無ければ、記録を増やさない。
+  assert.deepEqual(await settleAutoHandoffSourceGoal(db, { operationId: first.handoff_id, threadId: thread }, options('none')), { status: 'settled', goal: 'none' });
+  assert.equal(seen.recorded.length, 1);
+  // 後継が残っていない旧タスクは、今の続きなので触らない。
+  const gone = await settleAutoHandoffSourceGoal(db, { operationId: first.handoff_id, threadId: thread }, { ...options('active'), findThread: () => null });
+  assert.equal(gone.status, 'skipped'); assert.equal(seen.carried.length, 2);
+  await assert.rejects(settleAutoHandoffSourceGoal(db, { operationId: first.handoff_id, threadId: 'x y' }, options('active')), /handoff_thread_id_invalid/);
+}));
+
+test('公開CLIのsettle-goalは、引き継ぎIDと旧タスクのIDの両方を要る', () => {
+  const parsed = parseAutoHandoffArgs(['settle-goal', '--operation', 'id', '--thread', 'thread', '--json']);
+  assert.equal(parsed.action, 'settle-goal'); assert.equal(parsed.operation, 'id'); assert.equal(parsed.thread, 'thread');
+  for (const args of [['settle-goal', '--operation', 'id'], ['settle-goal', '--thread', 'thread'],
+    ['settle-goal', '--operation', 'id', '--thread', 'thread', '--host', 'claude']]) {
+    assert.throws(() => parseAutoHandoffArgs(args));
+  }
+});