create-walle 0.10.1 → 0.10.3

package/template/coding-task-manager/lib/landing/window.js

@@ -0,0 +1,57 @@
+'use strict';
+// WP-1 (docs/landing-pipeline-batched-multi-host-2026-10-30.html §5 D-3, §6, §8 WP-1, §9 S-1):
+// the adaptive batch window.
+//
+// The window is how many runnable queued jobs one gate is asked to cover. It is Zuul's rule: +1 on a
+// batch PASS (up to `landing.batch.max`), halve on a batch FAIL (never below 1). A window of 1 is
+// exactly the serial queue that existed before this change, so a repository that never writes the
+// file keeps today's behaviour.
+//
+// State lives at `<landing-dir>/window.json` — the same directory, the same atomic writer and the
+// same `contract` stamp as every other file the queue owns (`state.js`). Nothing here reads git,
+// spawns a process or knows about jobs: it is one integer and one transition.
+
+const path = require('path');
+
+const state = require('./state');
+
+const DEFAULT_SIZE = 1;
+const FILE = 'window.json';
+
+function windowFile(root) {
+  return path.join(root, FILE);
+}
+
+function normalize(raw) {
+  if (!raw || typeof raw !== 'object') return DEFAULT_SIZE;
+  // Strictly a number: a `"8"` written by hand is a malformed window, and the safe reading of a
+  // malformed window is the serial one.
+  if (typeof raw.size !== 'number' || !Number.isInteger(raw.size) || raw.size < 1) return DEFAULT_SIZE;
+  return raw.size;
+}
+
+// `{ size }`, defaulting to `{ size: 1 }` when the file is absent, unreadable or malformed — an
+// unknown window is the conservative one (today's serial behaviour), never a silent batch of eight.
+function readWindow(root) {
+  return { size: normalize(state.readJsonSafe(windowFile(root))) };
+}
+
+// D-3: the transition, read-modify-write inside the queue's mutex (the runner is the only writer, but
+// the file lives beside every other piece of shared state and gets the same protection). `max` is the
+// ceiling (`landing.batch.max`, ≥ 1): a PASS never grows past it and a FAIL never shrinks below 1.
+function bumpWindow(root, verdict, max) {
+  const ceiling = Number.isInteger(max) && max >= 1 ? max : DEFAULT_SIZE;
+  return state.withMutex(root, () => {
+    const before = readWindow(root).size;
+    const size = verdict === 'PASS' ? Math.min(before + 1, ceiling) : Math.max(Math.floor(before / 2), 1);
+    state.writeJsonAtomic(windowFile(root), { contract: state.CONTRACT, size });
+    return { size, before };
+  });
+}
+
+module.exports = {
+  DEFAULT_SIZE,
+  windowFile,
+  readWindow,
+  bumpWindow,
+};

package/template/coding-task-manager/lib/launch-environment.js

@@ -0,0 +1,121 @@
+'use strict';
+
+// WP-0 of docs/launch-environment-host-carried-adoption-2026-10-26.html (§5 D-1, §6).
+//
+// ONE rule-versioned capture function for the per-session launch environment. The record it produces is a
+// self-describing OBSERVATION -- { rule, state, values, reason } -- never a verdict about the session: it
+// carries the rule that produced it (LAUNCH_ENV_RULE) so a later reader can convert a record written under
+// an older rule (see lib/adopted-launch-environment.js, WP-2) instead of guessing. `rule` is an ordinal,
+// not a content hash; the hash of the rule's inputs lives in tests/launch-environment.test.js
+// (launchEnvironmentRuleDigest) so changing a projected key, a bound or the credential regex without
+// bumping LAUNCH_ENV_RULE fails loudly.
+//
+// Dependency-free on purpose: node:crypto (rule digest) and node:buffer (byte bounds). No fs, no config.
+
+const crypto = require('node:crypto');
+const { Buffer } = require('node:buffer');
+
+// Rule 2 = "the projected launch-context keys HOME/CODEX_HOME/TMPDIR are not private" (the rule since
+// 4768eeced3); rule 1 = the pre-2026-10-25 reading.
+const LAUNCH_ENV_RULE = 2;
+
+// The keys a lead-model switch re-projects into the launch context (lib/lead-model-restore-reconciliation.js
+// projectDeferredRestoreLaunch: HOME / CODEX_HOME from the launch context, TMPDIR alongside them). They are
+// PROJECTED launch context, not per-session private overrides: a spawn still receives them, but their presence
+// must never turn an otherwise empty override set into a private environment that only a surviving owner can
+// reproduce. Anything else in the env is private and is captured by value.
+const PROJECTED_LAUNCH_CONTEXT_KEYS = Object.freeze(['HOME', 'CODEX_HOME', 'TMPDIR']);
+
+// Bounds of a capturable private environment (moved here from lib/lead-model-restore-reconciliation.js).
+const MAX_SOURCE_ENV_ENTRIES = 64;
+const MAX_SOURCE_ENV_BYTES = 32 * 1024;
+const MAX_SOURCE_ENV_VALUE_BYTES = 8 * 1024;
+
+// A key whose value is credential-shaped must never be written to a handoff manifest file.
+const CREDENTIAL_KEY_RE = /(?:API_KEY|AUTH_TOKEN|_TOKEN|SECRET|PASSWORD|CREDENTIAL)/i;
+
+const LAUNCH_ENV_STATES = Object.freeze(['captured', 'captured-empty', 'unavailable']);
+const LAUNCH_ENV_REASONS = Object.freeze(['not_object', 'too_many_entries', 'bad_key', 'bad_value',
+  'too_many_bytes', 'credential_keys', 'legacy_worker_private_env', 'legacy_no_receipt']);
+
+const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+
+/** Returns a NEW object holding only the non-projected entries of `env`; never mutates its input and maps a
+ * non-object to `{}`. */
+function privateOverridesFromEnv(env) {
+  if (!env || typeof env !== 'object' || Array.isArray(env)) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (!PROJECTED_LAUNCH_CONTEXT_KEYS.includes(key)) out[key] = value;
+  }
+  return out;
+}
+
+function unavailable(reason) {
+  return Object.freeze({ rule: LAUNCH_ENV_RULE, state: 'unavailable', values: null, reason });
+}
+
+/** Captures a raw per-session private environment. Frozen result; never throws. */
+function captureLaunchEnvironment(privateEnv) {
+  if (!privateEnv || typeof privateEnv !== 'object' || Array.isArray(privateEnv)) return unavailable('not_object');
+  const entries = Object.entries(privateEnv);
+  if (entries.length > MAX_SOURCE_ENV_ENTRIES) return unavailable('too_many_entries');
+  const values = {};
+  let bytes = 0;
+  for (const [key, value] of entries) {
+    if (!ENV_KEY_RE.test(key)) return unavailable('bad_key');
+    if (typeof value !== 'string' || value.includes('\0')
+        || Buffer.byteLength(value, 'utf8') > MAX_SOURCE_ENV_VALUE_BYTES) return unavailable('bad_value');
+    bytes += Buffer.byteLength(key, 'utf8') + Buffer.byteLength(value, 'utf8');
+    if (bytes > MAX_SOURCE_ENV_BYTES) return unavailable('too_many_bytes');
+    values[key] = value;
+  }
+  const state = entries.length ? 'captured' : 'captured-empty';
+  return Object.freeze({ rule: LAUNCH_ENV_RULE, state, values: Object.freeze(values), reason: null });
+}
+
+// A record is a NEW frozen object rebuilt from validated fields: a tampered record (extra fields, a
+// non-frozen values object, values that no longer satisfy the bounds) never reaches a caller as itself.
+function normalizeLaunchEnvironment(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  if (value.rule !== LAUNCH_ENV_RULE || !LAUNCH_ENV_STATES.includes(value.state)) return null;
+  if (value.state === 'unavailable') {
+    if (typeof value.reason !== 'string' || !LAUNCH_ENV_REASONS.includes(value.reason)) return null;
+    if (value.values !== null) return null;
+    return Object.freeze({ rule: LAUNCH_ENV_RULE, state: 'unavailable', values: null, reason: value.reason });
+  }
+  if (value.reason !== null) return null;
+  const recaptured = captureLaunchEnvironment(value.values);
+  if (recaptured.state !== value.state) return null;
+  return Object.freeze({ rule: LAUNCH_ENV_RULE, state: value.state, values: recaptured.values, reason: null });
+}
+
+/** Validator in the `modelStorageRootsMetadata` style: `{}` or `{ launchEnvironment: frozenRecord }` so a
+ * caller spreads it. Only rule-2 records whose declared state agrees with a re-capture are accepted. With
+ * `{ manifest: true }` a record whose values hold a CREDENTIAL_KEY_RE key is REWRITTEN to
+ * `{ rule, state:'unavailable', values:null, reason:'credential_keys' }` (so no secret reaches the 0600
+ * manifest file); the other record keeps its values. */
+function launchEnvironmentMetadata(value, { manifest = false } = {}) {
+  const record = normalizeLaunchEnvironment(value);
+  if (!record) return {};
+  if (manifest && record.values && Object.keys(record.values).some((key) => CREDENTIAL_KEY_RE.test(key))) {
+    return { launchEnvironment: Object.freeze({ rule: LAUNCH_ENV_RULE, state: 'unavailable', values: null,
+      reason: 'credential_keys' }) };
+  }
+  return { launchEnvironment: record };
+}
+
+/** sha256 over the rule's inputs: projected keys, bounds and the credential regex. Pinned in
+ * tests/launch-environment.test.js -- bump LAUNCH_ENV_RULE and add a converter case when it changes. */
+function launchEnvironmentRuleDigest() {
+  return crypto.createHash('sha256').update(JSON.stringify({
+    rule: LAUNCH_ENV_RULE,
+    projected: PROJECTED_LAUNCH_CONTEXT_KEYS,
+    limits: [MAX_SOURCE_ENV_ENTRIES, MAX_SOURCE_ENV_BYTES, MAX_SOURCE_ENV_VALUE_BYTES],
+    credentialRe: CREDENTIAL_KEY_RE.source,
+  })).digest('hex');
+}
+
+module.exports = { LAUNCH_ENV_RULE, PROJECTED_LAUNCH_CONTEXT_KEYS, LAUNCH_ENV_STATES, LAUNCH_ENV_REASONS,
+  privateOverridesFromEnv, captureLaunchEnvironment, launchEnvironmentMetadata, launchEnvironmentRuleDigest,
+  MAX_SOURCE_ENV_ENTRIES, MAX_SOURCE_ENV_BYTES, MAX_SOURCE_ENV_VALUE_BYTES, CREDENTIAL_KEY_RE };

package/template/coding-task-manager/lib/launch-model-override.js

@@ -19,12 +19,12 @@
 //
 // Pure: never mutates `args`, never reads the DB or the environment.
 
-const MODEL_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:/@+\-[\]]*$/;
-const MAX_MODEL_ID_LENGTH = 200;
+const {
+  CLAUDE_OPTION_SIGNATURES, CLAUDE_SHORT_OPTIONS, locateClaudeSettingsArg,
+} = require('./native-lead-settings-argv');
 
-function isValidOverrideModel(model) {
-  return typeof model === 'string' && model.length > 0 && model.length <= MAX_MODEL_ID_LENGTH && MODEL_ID_RE.test(model);
-}
+// The ONE model-id rule lives in a leaf module (the session host loads it); re-exported here.
+const { isValidOverrideModel } = require('./model-id-rule');
 
 // Drops an existing `--model X` / `--model=X` / `-m X` / `-m=X` so the override is the only model flag.
 function stripModelFlags(args) {
@@ -38,12 +38,30 @@ function stripModelFlags(args) {
   return out;
 }
 
+// OpenCode's OWN launcher form (docs/opencode-lead-and-delegate-model-selection-2026-10-28.html §6.3,
+// R-8): the TUI's global flags come first and `--model` is spelled the long way only. Kept separate
+// from `stripModelFlags` above so the Claude/Codex argv grammar (where `-m` is the Codex global and
+// the model flag is appended/anchored) is never changed by an OpenCode-only rule.
+function stripOpencodeModelFlags(args) {
+  const out = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = String(args[i]);
+    if (arg === '--model' || arg === '-m') { i += 1; continue; }
+    if (arg.startsWith('--model=') || arg.startsWith('-m=')) continue;
+    out.push(args[i]);
+  }
+  return out;
+}
+
 /**
- * @param {{ agentType: string, args: string[], model: unknown }} input
+ * @param {{ agentType: string, args: string[], model: unknown, line?: 'v1'|'v2'|null }} input
+ *   `line` is the OpenCode binary's shape (lib/opencode-cli.js). It matters ONLY for
+ *   `agentType === 'opencode'`; every other agent ignores it, and `null`/absent keeps the 1.x
+ *   behaviour byte-identical.
  * @returns {{ args: string[], applied: boolean, reason: string }}
  *   applied=false returns the input args untouched (same array) with the reason why.
  */
-function applyLaunchModelOverride({ agentType, args, model } = {}) {
+function applyLaunchModelOverride({ agentType, args, model, line } = {}) {
   const list = Array.isArray(args) ? args : [];
   if (model == null || model === '') return { args: list, applied: false, reason: 'none' };
   if (!isValidOverrideModel(model)) return { args: list, applied: false, reason: 'invalid_model' };
@@ -64,6 +82,18 @@ function applyLaunchModelOverride({ agentType, args, model } = {}) {
     const head = stripModelFlags(list.slice(0, resumeIdx));
     return { args: [...head, '-m', model, ...list.slice(resumeIdx)], applied: true, reason: '' };
   }
+  if (agentType === 'opencode') {
+    // 2.x (R-4, WP-4): the TUI rejects `--model`, so the target never touches this argv. Strip every
+    // prior model flag so a stale one cannot survive either; the model rides the inline config +
+    // plugin `switch_model` the spawn path writes (lib/session-create/subagent-pick.js
+    // opencodeV2PluginEnv). `applied:true` records that the switch IS carried, just not here.
+    if (line === 'v2') return { args: stripOpencodeModelFlags(list), applied: true, reason: 'opencode-v2-plugin-carrier' };
+    // 1.x: OpenCode takes its global flags first; strip every prior model flag (`--model X`,
+    // `--model=X`, `-m X`, `-m=X`). This rides a FRESH relaunch only (a resumed 1.x conversation
+    // keeps the model its last user message recorded -- §5 R-4), so the launcher never has to
+    // reconcile a resume.
+    return { args: ['--model', model, ...stripOpencodeModelFlags(list)], applied: true, reason: '' };
+  }
   return { args: list, applied: false, reason: 'unsupported_agent' };
 }
 
@@ -204,6 +234,160 @@ function ensureCodexResumeTarget(argv, providerThreadId) {
   return { ok: true, args };
 }
 
+// --- Claude native same-thread resume normalization (D-2) ----------------------------------------
+// docs/claude-routed-native-history-resume-2026-10-24.html §5 D-2, §6. A Claude lead whose model or
+// route changes continues the SAME native thread: the canonical source owner's provider thread is
+// the authority, never a stale startup/parent selector in the recorded argv. This normalizer turns
+// every conversation selector the installed CLI accepts (`--resume`/`-r`, `--continue`/`-c`,
+// `--session-id`, `--from-pr`) into exactly one explicit `--resume <canonical>` placed FIRST, drops a
+// fork (which would mint a different identity), and removes the original positional startup prompt so
+// it cannot execute a second time. Every other option keeps its token and its operand boundary.
+//
+// Pure: no fs, no clock, never mutates `argv`, never reads a file, never changes model/auth.
+const CLAUDE_THREAD_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const CLAUDE_LONG_ARITY = new Map(CLAUDE_OPTION_SIGNATURES);
+// Every option token that SELECTS which conversation the CLI opens, including the ones that would
+// start a DIFFERENT one. Each is replaced by the canonical owner's own explicit resume: an old
+// `--session-id` would START that id again (colliding with the recorded transcript), `--continue`/`-c`
+// would not even name a thread, and `--from-pr` names a conversation that is not this one at all.
+const CLAUDE_CONVERSATION_SELECTORS = new Set(['--resume', '--session-id', '--continue', '--from-pr']);
+const CLAUDE_CONVERSATION_SELECTOR_SHORTS = new Set(['r', 'c']);
+// A recorded thread is continued IN PLACE: a fork would mint a new session identity, which is not what
+// this operation does, so it is dropped. `--replay-user-messages` is deliberately NOT here -- it only
+// changes how output is streamed and names no conversation identity, so it is preserved untouched.
+const CLAUDE_FORK_MODIFIERS = new Set(['--fork-session']);
+
+// Commander's own option-likeness rule: a lone `-` is an OPERAND, `--` is the terminator.
+function _isClaudeOptionLike(token) {
+  return typeof token === 'string' && token.length > 1 && token[0] === '-';
+}
+
+// One pass over an installed-CLI Claude argv, modelling Commander's operand consumption exactly
+// (`combineFlagAndOptionalValue` = true, so a short option's attached remainder is its value; a
+// required operand is consumed unconditionally; an optional one only when the next token is not
+// option-like; a variadic one takes its first operand plus every following non-option token). An
+// operand that merely SPELLS `--resume`/`--session-id` is therefore never read as a selector.
+//
+// Selector tokens are dropped and every OTHER token is returned untouched, in its original order, with
+// its own operand. A mixed short cluster keeps its non-selector members (rebuilt, with any attached
+// value) instead of losing flags: `-pc` becomes `-p`, `-cd value` becomes `-d value`, `-dp` is left
+// alone (`d` takes `p` as its value, so there is no selector in it at all).
+function _claudeResumeKeptTokens(args) {
+  const kept = [];
+  let index = 0;
+  while (index < args.length) {
+    const token = String(args[index]);
+    // A real terminator: every remaining token is positional, i.e. this launch's own prompt.
+    if (token === '--') break;
+    if (token.startsWith('--') && token.length > 2) {
+      const equalsAt = token.indexOf('=');
+      const name = equalsAt === -1 ? token : token.slice(0, equalsAt);
+      const inlineValue = equalsAt === -1 ? null : token.slice(equalsAt + 1);
+      const arity = CLAUDE_LONG_ARITY.get(name);
+      if (!arity) return { ok: false };
+      if (arity === 'boolean') {
+        if (inlineValue !== null) return { ok: false };
+        if (!CLAUDE_CONVERSATION_SELECTORS.has(name) && !CLAUDE_FORK_MODIFIERS.has(name)) kept.push(args[index]);
+        index += 1;
+        continue;
+      }
+      let end = index + 1;
+      if (inlineValue === null) {
+        if (arity === 'required') {
+          if (index + 1 >= args.length) return { ok: false };
+          end = index + 2;
+        } else if (arity === 'optional') {
+          if (args[index + 1] !== undefined && !_isClaudeOptionLike(args[index + 1])) end = index + 2;
+        } else { // variadic
+          if (index + 1 >= args.length) return { ok: false };
+          end = index + 2;
+          while (end < args.length && args[end] !== '--' && !_isClaudeOptionLike(args[end])) end += 1;
+        }
+      }
+      if (!CLAUDE_CONVERSATION_SELECTORS.has(name)) for (let i = index; i < end; i += 1) kept.push(args[i]);
+      index = end;
+      continue;
+    }
+    if (token.startsWith('-') && token.length > 1) {
+      const cluster = token.slice(1);
+      let position = 0;
+      let consumed = 1;
+      let rebuilt = '';
+      let selector = false;
+      let keepsOperand = false;
+      while (position < cluster.length) {
+        const character = cluster[position];
+        const spec = CLAUDE_SHORT_OPTIONS[character];
+        if (!spec) return { ok: false };
+        const isSelector = CLAUDE_CONVERSATION_SELECTOR_SHORTS.has(character);
+        const arity = spec[1];
+        if (arity === 'boolean') {
+          if (isSelector) selector = true; else rebuilt += character;
+          position += 1;
+          continue;
+        }
+        // `optional`/`required`: the whole attached remainder is this option's value, so the cluster
+        // has no further members.
+        const attached = cluster.slice(position + 1);
+        if (attached) {
+          if (isSelector) selector = true; else rebuilt += character + attached;
+          break;
+        }
+        if (arity === 'required') {
+          if (index + 1 >= args.length) return { ok: false };
+          consumed = 2;
+        } else {
+          consumed = args[index + 1] !== undefined && !_isClaudeOptionLike(args[index + 1]) ? 2 : 1;
+        }
+        if (isSelector) selector = true; else { rebuilt += character; keepsOperand = consumed === 2; }
+        break;
+      }
+      if (selector) {
+        // The non-selector members survive; a non-selector member that consumed the next token keeps
+        // that operand too.
+        if (rebuilt) kept.push(`-${rebuilt}`);
+        if (keepsOperand) kept.push(args[index + 1]);
+        index += consumed;
+        continue;
+      }
+      for (let i = index; i < index + consumed; i += 1) kept.push(args[i]);
+      index += consumed;
+      continue;
+    }
+    index += 1; // a positional token is this launch's own startup prompt: it is never replayed
+  }
+  return { ok: true, kept };
+}
+
+/**
+ * Normalize an installed-CLI Claude argv to resume exactly the canonical source thread.
+ *
+ * @param {string[]} argv the recorded startup/restore arguments (never mutated)
+ * @param {string} providerThreadId the canonical source owner's provider thread (a UUID)
+ * @returns {{ok:true,args:string[]}|{ok:false,reason:string}}
+ *   `claude_resume_target_invalid` — no canonical UUID was supplied;
+ *   `claude_resume_argv_unsupported` — malformed/ambiguous argv, an unknown option, a subcommand, or
+ *   the two installed parsers disagreeing about an operand span.
+ */
+function ensureClaudeResumeTarget(argv, providerThreadId) {
+  const args = Array.isArray(argv) ? argv : null;
+  const threadId = String(providerThreadId == null ? '' : providerThreadId).trim();
+  if (!args || !CLAUDE_THREAD_ID_RE.test(threadId)) return { ok: false, reason: 'claude_resume_target_invalid' };
+  for (const token of args) if (typeof token !== 'string') return { ok: false, reason: 'claude_resume_argv_unsupported' };
+  // The EXISTING settings/source adapter is the agreed-parse guard: a subcommand launch, an unknown
+  // option, or the two installed parsers disagreeing about a `--settings`/`--setting-sources` span
+  // is refused here instead of being reinterpreted as a conversation selector.
+  try { locateClaudeSettingsArg(args); }
+  catch { return { ok: false, reason: 'claude_resume_argv_unsupported' }; }
+  const scanned = _claudeResumeKeptTokens(args);
+  if (!scanned.ok) return { ok: false, reason: 'claude_resume_argv_unsupported' };
+  // The canonical resume goes FIRST, ahead of every preserved option token. That is what makes the
+  // result readable by the EXISTING `indexOf('--resume')` extractor even when another option's own
+  // operand spells `--resume`/`--session-id` (e.g. `--append-system-prompt --resume`): the first
+  // `--resume` in the produced argv is always this launch's canonical thread.
+  return { ok: true, args: ['--resume', threadId, ...scanned.kept] };
+}
+
 // --- Lead-model pin replay (claude-resume-managed-model-pin-2026-10-16.html §6 D-4/D-7) -----------
 // A managed policy (`model=opusplan`) makes a plain `claude --resume` restart an Opus session on
 // Sonnet, so the model the user explicitly chose is stored per session (WP-0 storage, WP-1 native
@@ -324,4 +508,5 @@ function applyLaunchEffortOverride(argv, agent, effort) {
 }
 
 module.exports = { applyLaunchModelOverride, isValidOverrideModel, applyLaunchEffortOverride, isValidEffort,
-  applyLaunchModelPin, stripModelFlags, insertBeforeCodexResume, rebindCodexForkLaunchPlan, ensureCodexResumeTarget };
+  applyLaunchModelPin, stripModelFlags, stripOpencodeModelFlags, insertBeforeCodexResume, rebindCodexForkLaunchPlan,
+  ensureCodexResumeTarget, ensureClaudeResumeTarget };

package/template/coding-task-manager/lib/launch-plan-pool.js

@@ -1172,7 +1172,8 @@ function createLaunchPlanCoordinator(options = {}) {
       // (or clearing it themselves) is an implicit "always recompute".
       // An explicit replacement bypasses the cache: the caller is saying the previous plan is no
       // longer valid, so replaying it would defeat the retry it asked for.
-      const warmKey = !replacement && warmPlanCacheEnabled && spec?.warmPlanInputs ? buildWarmPlanKey(spec.warmPlanInputs) : '';
+      const warmKey = !replacement && warmPlanCacheEnabled && spec?.warmPlanInputs ? buildWarmPlanKey({ ...spec.warmPlanInputs,
+        requestedLaunch: JSON.stringify([String(spec.cmd || ''), Array.isArray(spec.args) ? spec.args.map(String) : [], String(spec.modelId || '')]) }) : '';
       if (warmKey) {
         const cachedPlan = warmPlanCache.get(sessionId, warmKey);
         if (cachedPlan && states.get(sessionId)?.generation === generation

package/template/coding-task-manager/lib/launch-plan-warm-cache.js

@@ -32,6 +32,11 @@ function buildWarmPlanKey({
   // full-MCP argv and silently ignore the setting. Defaults to '' so a caller that never
   // sets a profile keeps a stable key.
   mcpProfile = '',
+  // The REQUESTED launch (cmd, argv, model) the plan is built from. A plan is a function of the
+  // argv it was handed, so a restore asking for `--session <id>` must never be served the plan of
+  // the earlier fresh launch: an OpenCode tab has no CTM transcript, so the other inputs never move
+  // after its first prompt (opencode-v2-model-switch-standalone-plugin-2026-10-30.html revision 2).
+  requestedLaunch = '',
 } = {}) {
   return [
     Number(transcriptMtimeMs) || 0,
@@ -40,6 +45,7 @@ function buildWarmPlanKey({
     Number(codexConfigMtimeMs) || 0,
     String(cliVersionStamp || ''),
     String(mcpProfile || ''),
+    String(requestedLaunch || ''),
   ].join('\u241F');
 }
 

package/template/coding-task-manager/lib/launch-plan-worker.js

@@ -16,10 +16,11 @@ const {
 } = require('./lifecycle-wake-experiment');
 const projectConfig = require('./project-config');
 const { resolveResumeCwdFallback } = require('./resume-cwd');
-const { validateResumeTarget, withTrashLocation } = require('./resume-preflight');
+const { validateResumeTarget, withTrashLocation, findClaudeResumeTranscript, transcriptHasConversation } = require('./resume-preflight');
 const { findTrashedTranscript } = require('./session-transcript-trash');
 const sessionHistory = require('./session-history');
 const { extractResumeTarget, getCodexThreadResumeCwdInfo, locateCodexRollout } = sessionHistory;
+const { ensureClaudeResumeTarget } = require('./launch-model-override');
 const walleMcpAutoConfig = require('./walle-mcp-auto-config');
 const { ensureWalleMcpForAgentSession } = walleMcpAutoConfig;
 const {
@@ -228,7 +229,15 @@ async function prepareLaunchPlan(spec = {}, progressPort = parentPort) {
   cwd = fallback.cwd || cwd;
 
   let agentType = agentTypeForCommand(cmd);
-  let resumeResolution = resolveResumeAlias(agentType, args, metadata);
+  // WP-0 D-2: for the PRIVATE Claude model-target operation below, the recorded source argv must reach
+  // the native-history classification UNTOUCHED. resolveResumeAlias is a naive
+  // `indexOf('--resume')` + metadata rewrite, and an argument that merely SPELLS `--resume` while being
+  // another option's operand (e.g. `--append-system-prompt --resume`) would be rewritten before the
+  // canonical normalizer ever sees it. Ordinary create/restore callers and Codex keep today's order.
+  const defersClaudeResumeAlias = agentType === 'claude' && spec.claudeResumeThreadId !== undefined;
+  let resumeResolution = defersClaudeResumeAlias
+    ? { args, resume: extractResumeTarget(agentType, args) }
+    : resolveResumeAlias(agentType, args, metadata);
   args = resumeResolution.args;
   let resume = resumeResolution.resume;
 
@@ -283,6 +292,54 @@ async function prepareLaunchPlan(spec = {}, progressPort = parentPort) {
   const cliResolution = resolvePublishedCliCommand(cmd, spec, env);
   cmd = cliResolution.cmd;
   agentType = agentTypeForCommand(cmd);
+  // WP-0 D-2 (same-harness, early): the project config above may have just rewritten this launch to a
+  // DIFFERENT harness, and the Codex-specific MCP/profile rewrites and prepareCodexLaunch() run long
+  // before a plan is returned. The private Claude model-target field names a Claude thread, so a launch
+  // that resolved to another harness is refused HERE -- before any of that preparation -- instead of
+  // executing Codex preparation and only then refusing the produced plan.
+  // Ordinary callers never set the private field, and Codex callers never set it either, so their
+  // behavior is unchanged. The planner's post-plan same-harness guard remains as the outer defence.
+  if (spec.claudeResumeThreadId !== undefined && agentType !== 'claude') {
+    const error = new TypeError('spec.claudeResumeThreadId names a Claude thread but the launch resolved to another harness');
+    error.code = 'launch_claude_target_harness_changed';
+    throw error;
+  }
+  // WP-0 (docs/claude-routed-native-history-resume-2026-10-24.html §5 D-2, §6): a Claude
+  // MODEL-TARGET preparation names the canonical source thread through the PRIVATE spec field
+  // `claudeResumeThreadId`, which only the lead-transition target planner sets after its canonical
+  // source proof. Claude keeps its own native transcript, so the launch must RESUME that exact
+  // thread instead of starting the recorded `--session-id` again (which would collide with the
+  // conversation already on disk). The classification below is the EXISTING native preflight --
+  // findClaudeResumeTranscript + transcriptHasConversation -- never a second reader, and nothing is
+  // written, moved, deleted or materialized here.
+  //
+  // A source with no recorded conversation is left EXACTLY as it is (today's fresh-launch
+  // behavior): forcing `--resume` onto a metadata-only stub is what the CLI answers with
+  // "No conversation found". The field is private to this worker spec, so an ordinary
+  // create/restore caller -- which never sets it -- cannot reach this block at all.
+  if (agentType === 'claude' && spec.claudeResumeThreadId !== undefined) {
+    const canonicalThreadId = String(spec.claudeResumeThreadId || '').trim();
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(canonicalThreadId)) {
+      const error = new TypeError('spec.claudeResumeThreadId must be the canonical Claude thread id');
+      error.code = 'launch_claude_resume_target_invalid';
+      throw error;
+    }
+    const canonicalTranscript = findClaudeResumeTranscript({
+      resumeId: canonicalThreadId,
+      jsonlPath: metadata.resumeAgent?.jsonl_path || metadata.resolved?.jsonl_path || '',
+      homeDir,
+      claudeConfigDir: env.CLAUDE_CONFIG_DIR || spec.claudeConfigDir,
+    });
+    if (canonicalTranscript && transcriptHasConversation(canonicalTranscript.path)) {
+      const normalized = ensureClaudeResumeTarget(args, canonicalThreadId);
+      if (!normalized.ok) {
+        const error = new TypeError(`the recorded Claude launch arguments cannot name the canonical thread: ${normalized.reason}`);
+        error.code = normalized.reason;
+        throw error;
+      }
+      args = normalized.args;
+    }
+  }
   resumeResolution = resolveResumeAlias(agentType, args, metadata);
   args = resumeResolution.args;
   resume = resumeResolution.resume;

package/template/coding-task-manager/lib/lead-model-observer.js

@@ -53,10 +53,40 @@ function provenTurnOutcome(turn) {
   return outcome && SETTLED_OUTCOMES.has(outcome) ? outcome : null;
 }
 
+// WP-1: the owner fields every Claude observation derives from its result (`withCapturedRouteOwner`
+// then overrides them from the item's captured owner when it has one).
+function claudeObservedOwner(result) {
+  return {
+    ...(Number.isSafeInteger(result.processGeneration) ? { processGeneration: result.processGeneration } : {}),
+    ...(typeof result.providerSessionId === 'string' ? { providerThreadId: result.providerSessionId } : {}),
+    ...(typeof result.profileFingerprint === 'string' ? { profileFingerprint: result.profileFingerprint } : {}),
+    ...(typeof result.routeId === 'string' ? { routeId: result.routeId } : {}),
+  };
+}
+
+/*
+ * WP-1/D-1: a REFUSED Claude turn, as the switch consumes it. `model` is EMPTY on purpose -- the
+ * refusal names no model, which is exactly why the switch's `no_model` guard used to swallow it. The
+ * failure is only open while it is NEWER than the newest successful turn; a good turn after it wins.
+ */
+function claudeFailureObservation(failure, observedOwner) {
+  const atMs = Number(failure.atMs) || 0;
+  const status = Number.isSafeInteger(failure.status) ? failure.status : null;
+  return {
+    model: '', outcome: 'failed', apiErrorStatus: status, error: `API Error ${status == null ? 'unknown' : status}`,
+    source: 'transcript:turn', observedAtMs: atMs,
+    ...(failure.turnId ? { turnId: String(failure.turnId) } : {}),
+    ...observedOwner,
+  };
+}
+
 function turnObservationFrom(item, result) {
   if (!result) return null;
   if (item?.agentType === 'claude') {
     const truth = result.modelTruth;
+    if (truth && truth.lastTurnFailure && Number(truth.lastTurnFailure.atMs) > Number(truth.lastTurnAtMs || 0)) {
+      return withCapturedRouteOwner(claudeFailureObservation(truth.lastTurnFailure, claudeObservedOwner(result)), item);
+    }
     if (truth && truth.lastTurn && Number(truth.lastTurnAtMs) > 0) {
       return withCapturedRouteOwner({
         model: String(truth.lastTurn), effort: truth.effort || null, source: 'transcript:turn', observedAtMs: Number(truth.lastTurnAtMs),
@@ -116,8 +146,20 @@ function nativeTurnObservation(item, result) {
   const source = item?.agentType === 'claude' ? 'transcript:turn' : item?.agentType === 'codex' ? 'codex:turn-context' : null;
   if (!source || !Array.isArray(result.observations)) return null;
   let best = null;
+  // WP-1/D-1: a refused turn arrives as its OWN observation kind; it is not a turn, so it never
+  // competes for `best` -- it only wins by being newer than the newest completed turn.
+  let bestFailure = null;
   for (const o of result.observations) {
-    if (!o || o.kind !== 'completed-turn' || o.source !== source) continue;
+    if (!o || o.source !== source) continue;
+    if (o.kind === 'failed-turn') {
+      const at = Number(o.observedAtMs);
+      if (!Number.isFinite(at) || at < 0) continue;
+      if (!bestFailure || at > bestFailure.at) bestFailure = { at, status: o.apiErrorStatus, turnId: o.sourceRevision || null,
+        processGeneration: o.processGeneration, providerThreadId: o.providerSessionId || null,
+        profileFingerprint: o.profileFingerprint || null, routeId: o.routeId || null };
+      continue;
+    }
+    if (o.kind !== 'completed-turn') continue;
     if (typeof o.value !== 'string' || !o.value.length) continue;
     const at = Number(o.observedAtMs);
     if (!Number.isFinite(at) || at < 0) continue;
@@ -128,6 +170,20 @@ function nativeTurnObservation(item, result) {
         profileFingerprint: o.profileFingerprint || null, routeId: o.routeId || null,
       };
   }
+  // A refusal newer than the newest successful turn is the answer; equal timestamps keep the
+  // completed turn, matching the decoder's own (timestamp, index) preference.
+  if (bestFailure && (!best || bestFailure.at > best.observedAtMs)) {
+    return withCapturedRouteOwner({
+      model: '', outcome: 'failed', apiErrorStatus: Number.isSafeInteger(bestFailure.status) ? bestFailure.status : null,
+      error: `API Error ${Number.isSafeInteger(bestFailure.status) ? bestFailure.status : 'unknown'}`,
+      source, observedAtMs: bestFailure.at,
+      ...(bestFailure.turnId ? { turnId: String(bestFailure.turnId) } : {}),
+      ...(Number.isSafeInteger(bestFailure.processGeneration) ? { processGeneration: bestFailure.processGeneration } : {}),
+      ...(bestFailure.providerThreadId ? { providerThreadId: String(bestFailure.providerThreadId) } : {}),
+      ...(bestFailure.profileFingerprint ? { profileFingerprint: String(bestFailure.profileFingerprint) } : {}),
+      ...(bestFailure.routeId ? { routeId: String(bestFailure.routeId) } : {}),
+    }, item);
+  }
   if (!best) return null;
   const obs = { model: String(best.model), effort: best.effort, source: best.source, observedAtMs: best.observedAtMs };
   if (best.turnId) obs.turnId = String(best.turnId);