create-walle 0.10.0 → 0.10.2

package/template/coding-task-manager/lib/codex-markdown-lists.js

@@ -0,0 +1,160 @@
+'use strict';
+
+// Codex list markers, at parity with what the TUI paints, ported from
+//   codex-rs/tui/src/markdown_render.rs             start_item (:1014-1090), prefix_spans (:2535-2565)
+//   codex-rs/tui/src/markdown_render/task_lists.rs  task_list_marker
+//   codex-rs/tui/src/markdown_render_tests.rs       list_unordered_single / list_nested / nested_five_levels_mixed_lists / ...
+//
+// Why this module exists: the reader joins CTM's rendered rows to the rows the live Codex screen
+// actually shows, by identity of the row text. Codex draws unordered items as `• ` (PR #47322, on
+// by default) and nests by a FIXED 4-column step, while the first CTM renderer drew `- ` indented by
+// floor(spaces/2)*2 — so every list row missed the join and the reader drew it twice.
+//
+// The two facts that make the port non-obvious:
+//   * depth is the list nesting level; `width = depth*4 - 3`. The marker of an item at depth d is
+//     ONLY its own marker: prefix_spans skips every list context except the innermost, so an outer
+//     level contributes nothing to a nested row (no cumulative indent).
+//   * depth is NOT floor(spaces/2). It comes from a CommonMark container stack over the source
+//     lines; each open level remembers its item's CONTENT column, and a list line either opens a
+//     deeper level, lands as a sibling, or closes levels.
+//
+// Pure: no DOM, no clock, no I/O. Same input => same output. Tabs are already expanded to 4 spaces
+// by the caller (renderMarkdownTextBlock does this before the line loop).
+
+const BULLET = '•';
+const UNCHECKED = '☐';
+const CHECKED = '☑';
+
+// Codex nests by a fixed 4-column step (markdown_render.rs:1042: `width = depth * 4 - 3`).
+const HANG_STEP = 4;
+
+// `- x` / `* x` / `+ x` and `1. x` / `1) x`. The content must be non-blank, so a bare rule or a
+// lone marker keeps falling through to the renderer's paragraph path exactly as before.
+const BULLET_LINE = /^( *)([-*+])( +)(\S.*)$/;
+const ORDERED_LINE = /^( *)(\d{1,4})([.)])( +)(\S.*)$/;
+// A GFM task checkbox, right after the marker (task_lists.rs:8-24). `[X]` counts as checked.
+const TASK = /^\[([ xX])\](?: |$)/;
+
+// `width` for a depth (markdown_render.rs:1042): depth 1 => 1, depth 2 => 5, depth 3 => 9 ...
+function markerWidthFor(depth) {
+  return depth * HANG_STEP - 3;
+}
+
+// The column a wrapped (continuation) row of this item hangs at (markdown_render.rs:1057-1061):
+// unordered `width + 1`, ordered `width + 2` whatever the digit count. A task item hangs at its whole
+// marker's display width instead (itemOf).
+function hangFor(entry) {
+  return entry.width + (entry.ordered ? 2 : 1);
+}
+
+// markdown_render.rs:1043-1056 + task_lists.rs:15-19: the task checkbox REPLACES a trailing `• `
+// and keeps an ordered `N. ` prefix.
+function markerFor(entry, index) {
+  const glyph = entry.task ? (entry.checked ? CHECKED : UNCHECKED) : BULLET;
+  if (!entry.ordered) return ' '.repeat(Math.max(0, entry.width - 1)) + glyph + ' ';
+  return String(index).padStart(entry.width) + '. ' + (entry.task ? glyph + ' ' : '');
+}
+
+// Builds the row a list item paints: the marker (which already carries its own leading columns)
+// plus the source text. `indent` is 0 for an item row because the marker string holds its column,
+// and `hang` is the absolute continuation column. The caller adds the message prefix in front
+// (rule R-1.6) and strips inline markdown from `text` alone, so the marker never joins a match.
+function itemOf(entry, index, text) {
+  const marker = markerFor(entry, index);
+  // A task item hangs at its WHOLE marker's display width (task_lists.rs:22), so `10. ☐ ` hangs 6;
+  // every char of a marker is one column wide.
+  return { marker, text, indent: 0, hang: entry.task ? marker.length : hangFor(entry) };
+}
+
+// A tracker owns the CommonMark container stack for one text block. `consume(line)` must be called
+// with EVERY source line, in order, including blank ones: a blank line does not close the stack,
+// and a non-list line may be a continuation paragraph of the innermost item.
+function createListTracker() {
+  const stack = []; // innermost last; each entry = { ordered, task, checked, width, contentCol, next }
+
+  const push = (fields) => {
+    const entry = {
+      ordered: fields.ordered,
+      task: fields.task,
+      checked: fields.checked,
+      width: markerWidthFor(stack.length + 1),
+      contentCol: fields.contentCol,
+      next: fields.next,
+    };
+    stack.push(entry);
+    return entry;
+  };
+
+  return {
+    // -> null when the line is not a list item (or a continuation of one); otherwise the row
+    //    { marker, text, indent, hang } the renderer draws. `marker` is '' for a continuation row.
+    consume(rawLine) {
+      const line = String(rawLine == null ? '' : rawLine);
+      if (!line.trim()) return null; // a blank line does not close (R-1.5)
+
+      const bullet = BULLET_LINE.exec(line);
+      const ordered = bullet ? null : ORDERED_LINE.exec(line);
+
+      if (!bullet && !ordered) {
+        const top = stack[stack.length - 1];
+        const indent = line.length - line.replace(/^ */, '').length;
+        if (top && indent >= top.contentCol) {
+          // A non-blank, non-list line indented to the item's content column continues that item,
+          // rendered at the level's hang (R-1.5).
+          const hang = hangFor(top);
+          return { marker: '', text: line.trim(), indent: hang, hang };
+        }
+        stack.length = 0; // any other non-blank line closes every level
+        return null;
+      }
+
+      const markerIndent = (bullet ? bullet[1] : ordered[1]).length;
+      // The marker LENGTH is `-` (1) or `N.` (digits + the bracket) — the checkbox is not part of
+      // it, so `- [ ] a` still has content column 2.
+      const markerLen = bullet ? 1 : ordered[2].length + 1;
+      const gap = (bullet ? bullet[3] : ordered[4]).length;
+      const contentCol = markerIndent + markerLen + gap;
+      const content = bullet ? bullet[4] : ordered[5];
+      const task = TASK.exec(content);
+      const isOrdered = !bullet;
+      const text = task ? content.slice(task[0].length) : content;
+      const fields = {
+        ordered: isOrdered,
+        task: !!task,
+        checked: !!task && task[1] !== ' ',
+        contentCol,
+        next: isOrdered ? Number(ordered[2]) : 0,
+      };
+
+      const top = stack[stack.length - 1];
+      let entry;
+      if (top && markerIndent >= top.contentCol) {
+        entry = push(fields); // deeper than the innermost item's content -> a nested level
+      } else {
+        // Pop while the marker column sits left of the content column of the level BELOW the top.
+        while (stack.length >= 2 && markerIndent < stack[stack.length - 2].contentCol) stack.pop();
+        const sibling = stack[stack.length - 1];
+        if (!sibling || sibling.ordered !== isOrdered) {
+          // A sibling of the other type starts a NEW list at this depth; its numbering restarts
+          // from its own first source number.
+          if (sibling) stack.pop();
+          entry = push(fields);
+        } else {
+          entry = sibling; // same list: keep the level, refresh the per-item task state
+          entry.task = fields.task;
+          entry.checked = fields.checked;
+        }
+      }
+
+      let index = 0;
+      if (entry.ordered) {
+        index = entry.next; // counts from the list's first source number, per sibling
+        entry.next += 1;
+      }
+
+      return itemOf(entry, index, text);
+    },
+  };
+}
+
+module.exports = { createListTracker };

package/template/coding-task-manager/lib/codex-native-history-prefix.js

@@ -191,6 +191,10 @@ function findCanonicalRolloutsByFilenameId(threadId, storageRoots) {
         const candidate = path.join(dir, entry.name);
         if (entry.isDirectory()) { stack.push({ dir: candidate, depth: depth + 1 }); continue; }
         if (!entry.isFile() || sessionHistory.codexRolloutIdFromPath(candidate).toLowerCase() !== wanted) continue;
+        // Codex rust-v0.163.0 rollout/src/compression.rs should_skip_compressed_sibling: one rollout is
+        // one physical file, and a `.jsonl.zst` is hidden while its plain `.jsonl` exists (Codex
+        // compresses an idle thread, then appends to a re-materialized plain file beside the stale copy).
+        if (candidate.endsWith('.jsonl.zst') && transcriptSource.statTranscriptSync(candidate.slice(0, -'.zst'.length)).exists) continue;
         const info = transcriptSource.statTranscriptSync(candidate);
         if (!info.exists) throw Object.assign(new Error('native history candidate changed during lookup'), { code: 'native_history_lineage_changed' });
         let canonical;

package/template/coding-task-manager/lib/codex-paths.js

@@ -26,6 +26,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
+const { isWritableOnlyByOwner } = require('../../shared/owner-write-safety');
 
 function homeBase(homeDir) {
   return homeDir || process.env.HOME || process.env.USERPROFILE || os.homedir() || '';
@@ -77,7 +78,7 @@ function resolveCodexSessionsRoot(options = {}) {
     out.refusalCode = 'wrong-owner';
     return out;
   }
-  if ((Number(stat.mode) & 0o022) !== 0) {
+  if (!isWritableOnlyByOwner(stat)) {
     out.validationStatus = 'refused';
     out.refusalCode = 'unsafe-permissions';
     return out;

package/template/coding-task-manager/lib/codex-source-handoff.js

@@ -0,0 +1,186 @@
+'use strict';
+
+/*
+ * WP-2 D-5/D-6 (docs/codex-lead-routed-switch-history-handoff-2026-10-21.html §6.3, §5 D-5/D-6).
+ *
+ * A GPT Codex lead whose last compaction holds an OpenAI-encrypted `compaction` item cannot carry
+ * that ciphertext to a routed target model. The user's decision (2026-10-21) is that the SOURCE GPT
+ * model writes a plaintext handoff summary before the switch.
+ *
+ * The summary is produced by an EPHEMERAL fork of the source thread, so:
+ *   - the user's live source PTY and source thread are never touched (anti-goal: never submit into
+ *     the live source session);
+ *   - no rollout file is persisted for the fork (measured on Codex 0.163.0: the rollout-file set is
+ *     byte-identical before and after);
+ *   - the turn is a real model turn on the user's own ChatGPT account (risk R-1: it spends quota and
+ *     can take up to HANDOFF_DEADLINE_MS, which is why the caller shows a "compacting" phase).
+ *
+ * This module owns the child process, the app-server JSON-RPC sequence, and the text validation. It
+ * writes nothing anywhere: the returned text travels in memory to lib/native-history-control.js,
+ * which injects it into the forked target as one developer message.
+ */
+
+const { spawn } = require('node:child_process');
+const crypto = require('node:crypto');
+const path = require('node:path');
+// The ONE process-launch/RPC implementation. `allowTurn: true` is what makes the handoff turn legal:
+// every fork and readback path keeps the fail-closed `native_fork_emitted_model_turn` guard.
+const { createBoundedRpc, terminateChild } = require('./native-history-control');
+
+// Codex rust-v0.163.0 codex-rs/prompts/templates/compact/prompt.md, verbatim (Apache-2.0; the file
+// carries the upstream copyright header). Kept byte-identical on purpose: the source model must be
+// asked the same question Codex asks its own compactor, or the summary is a different artifact.
+const CODEX_COMPACT_PROMPT = 'You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.\n'
+  + '\n'
+  + 'Include:\n'
+  + '- Current progress and key decisions made\n'
+  + '- Important context, constraints, or user preferences\n'
+  + '- What remains to be done (clear next steps)\n'
+  + '- Any critical data, examples, or references needed to continue\n'
+  + '\n'
+  + 'Be concise, structured, and focused on helping the next LLM seamlessly continue the work.\n';
+// The CTM addition (§6.3): what a provider switch additionally needs that a same-provider compaction
+// does not. It is not a tool-using turn -- the fork is read-only and every tool is refused.
+const CTM_HANDOFF_ADDITION = '\n\nAlso include, verbatim and complete: every file path you changed or must change, exact error strings and test names still failing, commands that must run next, and the single next action. Do not call tools. Reply with the summary only.';
+const HANDOFF_PROMPT = `${CODEX_COMPACT_PROMPT}${CTM_HANDOFF_ADDITION}`;
+
+const HANDOFF_MIN_CHARS = 200;
+const HANDOFF_MAX_CHARS = 32_768;
+const HANDOFF_DEADLINE_MS = 240_000;
+const HANDOFF_APP_SERVER_ARGS = Object.freeze(['app-server', '-c', 'approval_policy="never"',
+  '-c', 'sandbox_mode="read-only"']);
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const MARKER_PREFIX = '<ctm_handoff';
+
+/**
+ * Ask the SOURCE model for the plaintext handoff that will cover its sealed compaction.
+ *
+ * @param {{executablePath:string, homeDir:string, codexHome:string, workingDirectory:string, tmpDir?:string|null}} source
+ * @param {{sourceThreadId:string, lastTurnId:string}} checkpoint
+ * @param {{signal?:AbortSignal, timeoutMs?:number}} [opts]
+ * @returns {Promise<{ok:true, text:string, textSha256:string, turnId:string, model:string|null}
+ *   | {ok:false, reason:'handoff_fork_failed'|'handoff_turn_failed'|'handoff_empty'|'handoff_too_long'
+ *     |'handoff_marker_in_text'|'handoff_timeout'|'transition_cancelled'}>}
+ */
+async function writeSourceHandoff(source, checkpoint, { signal, timeoutMs } = {}) {
+  if (signal?.aborted) return failure('transition_cancelled');
+  const sourceThreadId = nonempty(checkpoint?.sourceThreadId);
+  const lastTurnId = nonempty(checkpoint?.lastTurnId);
+  const executablePath = nonempty(source?.executablePath);
+  if (![executablePath, source?.homeDir, source?.codexHome, source?.workingDirectory]
+    .every((value) => typeof value === 'string' && path.isAbsolute(value))
+      || (source?.tmpDir != null && !path.isAbsolute(source.tmpDir))
+      || !UUID_RE.test(sourceThreadId) || !lastTurnId) return failure('handoff_fork_failed');
+  const deadlineMs = Number.isSafeInteger(timeoutMs) && timeoutMs > 0
+    ? Math.min(timeoutMs, HANDOFF_DEADLINE_MS) : HANDOFF_DEADLINE_MS;
+  const state = { turnId: '', completed: null, agentText: '', onComplete: null };
+  let stage = 'fork';
+  let child = null;
+  let rpc = null;
+  try {
+    child = spawn(executablePath, [...HANDOFF_APP_SERVER_ARGS], { cwd: source.workingDirectory,
+      env: handoffEnv(source), stdio: ['pipe', 'pipe', 'pipe'] });
+    child.stderr.resume();
+    rpc = createBoundedRpc(child, { signal, timeoutMs: deadlineMs, allowTurn: true,
+      onNotification: (method, params) => observe(state, method, params) });
+    const initialized = await rpc.request('initialize', {
+      clientInfo: { name: 'ctm-source-handoff', version: '1' }, capabilities: {},
+    });
+    if (!initialized || rpc.closed) return failure('handoff_fork_failed');
+    await rpc.notify('initialized', {});
+    const forked = await rpc.request('thread/fork', { threadId: sourceThreadId, lastTurnId,
+      ephemeral: true, excludeTurns: true });
+    const ephemeralId = nonempty(forked?.thread?.id || forked?.threadId || forked?.thread_id);
+    if (!UUID_RE.test(ephemeralId) || ephemeralId === sourceThreadId) return failure('handoff_fork_failed');
+    stage = 'turn';
+    const started = await rpc.request('turn/start', { threadId: ephemeralId,
+      input: [{ type: 'text', text: HANDOFF_PROMPT }] });
+    state.turnId = nonempty(started?.turn?.id || started?.turnId || started?.id);
+    if (!state.turnId) return failure('handoff_turn_failed');
+    const turn = await waitForTurn(state, signal, deadlineMs);
+    if (signal?.aborted) return failure('transition_cancelled');
+    if (!turn || turn.timedOut) return failure(turn ? 'handoff_timeout' : 'handoff_turn_failed');
+    if (nonempty(turn.status) !== 'completed') return failure('handoff_turn_failed');
+    const text = (agentMessageText(turn) || state.agentText).trim();
+    if (text.length < HANDOFF_MIN_CHARS) return failure('handoff_empty');
+    if (text.length > HANDOFF_MAX_CHARS) return failure('handoff_too_long');
+    // The target's own readback looks for this prefix; a summary that already contains one could
+    // forge coverage for an unrelated sealed item.
+    if (text.includes(MARKER_PREFIX)) return failure('handoff_marker_in_text');
+    return { ok: true, text, textSha256: sha256(text), turnId: state.turnId,
+      model: nonempty(turn.model || turn.modelId) || null };
+  } catch (error) {
+    if (signal?.aborted || error?.code === 'transition_cancelled') return failure('transition_cancelled');
+    if (error?.code === 'native_rpc_deadline') return failure('handoff_timeout');
+    return failure(stage === 'turn' ? 'handoff_turn_failed' : 'handoff_fork_failed');
+  } finally {
+    // The ephemeral fork must never outlive this call, on any path -- including a refusal or an abort.
+    if (rpc) await rpc.close();
+    else await terminateChild(child);
+  }
+}
+
+function handoffEnv(source) {
+  const env = { PATH: process.env.PATH || '/usr/bin:/bin', HOME: source.homeDir,
+    CODEX_HOME: source.codexHome, LANG: process.env.LANG || 'C',
+    CTM_PROCESS_ROLE: 'ctm-source-handoff' };
+  if (source.tmpDir) env.TMPDIR = source.tmpDir;
+  return env;
+}
+
+// The single notification sink: turn/completed carries the finished turn (with its items), and
+// item/completed is the fallback if a Codex version reports the agent message only there.
+function observe(state, method, params) {
+  if (method === 'item/completed') {
+    const item = params?.item;
+    if (nonempty(item?.type) === 'agentMessage' && typeof item.text === 'string'
+        && (!state.turnId || nonempty(params?.turnId || item.turn_id) === state.turnId)) {
+      state.agentText = item.text;
+    }
+    return;
+  }
+  if (method !== 'turn/completed') return;
+  const turn = params?.turn;
+  if (state.turnId && nonempty(turn?.id) !== state.turnId) return;
+  state.completed = isRecord(turn) ? turn : null;
+  const settle = state.onComplete;
+  state.onComplete = null;
+  if (settle) settle(state.completed);
+}
+
+function waitForTurn(state, signal, deadlineMs) {
+  if (state.completed) return Promise.resolve(state.completed);
+  return new Promise((resolve) => {
+    let settled = false;
+    const timer = setTimeout(() => finish({ timedOut: true }), deadlineMs);
+    const onAbort = () => finish(null);
+    function finish(value) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      state.onComplete = null;
+      signal?.removeEventListener('abort', onAbort);
+      resolve(value);
+    }
+    state.onComplete = finish;
+    signal?.addEventListener('abort', onAbort, { once: true });
+    if (state.completed) finish(state.completed);
+  });
+}
+
+function agentMessageText(turn) {
+  if (!Array.isArray(turn?.items)) return '';
+  for (let index = turn.items.length - 1; index >= 0; index -= 1) {
+    const item = turn.items[index];
+    if (nonempty(item?.type) === 'agentMessage' && typeof item.text === 'string') return item.text;
+  }
+  return '';
+}
+
+function failure(reason) { return { ok: false, reason }; }
+function sha256(value) { return crypto.createHash('sha256').update(value).digest('hex'); }
+function nonempty(value) { return typeof value === 'string' && value.trim() ? value.trim() : ''; }
+function isRecord(value) { return !!value && typeof value === 'object' && !Array.isArray(value); }
+
+module.exports = { writeSourceHandoff, HANDOFF_PROMPT, HANDOFF_MIN_CHARS, HANDOFF_MAX_CHARS,
+  HANDOFF_DEADLINE_MS };

package/template/coding-task-manager/lib/coding-agent-models.js

@@ -288,18 +288,6 @@ function isGenericCodingSessionLabel(label, agentType = 'codex') {
     || lower === 'session';
 }
 
-function shouldApplyCodexAutoTitle({ session, existingTitle } = {}) {
-  if (existingTitle && existingTitle.userRenamed) return false;
-  for (const candidate of [session?.label, existingTitle?.title]) {
-    const text = normalizeTitleText(candidate);
-    if (text && !/^Codex:\s*/i.test(text) && !isGenericCodingSessionLabel(text, 'codex')) return false;
-  }
-  const title = normalizeTitleText(existingTitle?.title || session?.label || '');
-  if (!title) return true;
-  if (/^Codex:\s*/i.test(title) && !isGenericCodingSessionLabel(title, 'codex')) return true;
-  return isGenericCodingSessionLabel(title, 'codex');
-}
-
 function resolveModelToRegistry(modelName) {
   if (!modelName) return null;
   let provider = null;
@@ -561,11 +549,23 @@ function createCodingAgentModelSync({
         if (!modelStateRuntime) _persistSessionModel(session, model);
         changed = true;
       }
-      if (agentType === 'codex' && !session._codexTitleSynced) {
+      if (agentType === 'codex') {
         const existingTitle = titlesById.get(session.id) || null;
-        if (existingTitle && existingTitle.userRenamed) {
-          session._codexTitleSynced = true;
-        } else if (!shouldApplyCodexAutoTitle({ session, existingTitle })) {
+        // WP-4/D-10: the thread's OWN name (threads.name) is read on EVERY tick — there is no
+        // one-shot `_codexTitleSynced` latch any more, and no title-vs-label precedence test that
+        // could let a CTM title block the name (S-22). applyProviderTitle owns the tier rules: it
+        // re-asserts a drifted tier-1 (user-renamed) row outward, skips a row already carrying this
+        // exact name, and writes the agent name over an older tier-2/tier-3 title.
+        const agentName = session._claudeSessionId ? getCodexThreadAgentName(session._claudeSessionId) : '';
+        if (agentName) {
+          const outcome = applyProviderTitle({ db: dbModule, sessionId: session.id, provider: 'codex', agentName }); // not a dbModule method — no dispatchOwnerMutation
+          if (outcome.applied === 'agent') {
+            session.label = `Codex: ${agentName}`;
+            changed = true;
+          }
+        } else {
+          // No thread name at all: the CTM live label is the only signal left, so it repairs a
+          // stale auto-title. Never a tier-2 (`provider_title`) row, never the user's own name.
           const liveLabel = normalizeTitleText(session.label);
           if (liveLabel
             && !isGenericCodingSessionLabel(liveLabel, 'codex')
@@ -573,16 +573,6 @@ function createCodingAgentModelSync({
             dispatchOwnerMutation(dbModule, 'setSessionTitleNew', [session.id, liveLabel, false], 'coding-agent title');
             changed = true;
           }
-          session._codexTitleSynced = true;
-        } else {
-          // Requires the exact Codex thread id — cwd/spawn-time matching is unsafe for periodic refresh.
-          const agentName = session._claudeSessionId ? getCodexThreadAgentName(session._claudeSessionId) : '';
-          if (agentName) {
-            session.label = `Codex: ${agentName}`;
-            session._codexTitleSynced = true;
-            applyProviderTitle({ db: dbModule, sessionId: session.id, provider: 'codex', agentName }); // not a dbModule method — no dispatchOwnerMutation
-            changed = true;
-          }
         }
       }
     }
@@ -688,7 +678,7 @@ function createCodingAgentModelSync({
       if (agentType === 'gemini' && !modelStateRuntime) {
         context.result = { id: session.id, modelName: _modelArgValue(session.args) };
       } else {
-        const item = { id: session.id, agentType, directory: session.cwd || (session.meta && session.meta.cwd) || '', knownSourceRevision: agentType === 'opencode' ? modelSyncState.knownSourceRevision(session.id) : '', claudeJsonlPath, codexThreadId: agentType === 'codex' ? (session._providerResumeId || session._claudeSessionId || '') : (session._claudeSessionId || session._providerResumeId || null), wantCodexTitle: agentType === 'codex' && session._codexTitleSynced !== true && !!(session._providerResumeId || session._claudeSessionId) };
+        const item = { id: session.id, agentType, directory: session.cwd || (session.meta && session.meta.cwd) || '', knownSourceRevision: agentType === 'opencode' ? modelSyncState.knownSourceRevision(session.id) : '', claudeJsonlPath, codexThreadId: agentType === 'codex' ? (session._providerResumeId || session._claudeSessionId || '') : (session._claudeSessionId || session._providerResumeId || null), wantCodexTitle: agentType === 'codex' && !!(session._providerResumeId || session._claudeSessionId) }; // WP-4/D-10: no one-shot latch gates the name read
         if (modelStateRuntime) {
           Object.assign(item, { owner: context.ownerSnapshot, providerSessionId: context.ownerSnapshot.providerSessionId, processGeneration: context.ownerSnapshot.processGeneration, providerEnv: modelProviderEnv(session), geminiTranscriptPath: session._geminiTranscriptPath || '' });
           // The pre-await half of the source binding, and the prior checkpoint this request may carry.
@@ -758,7 +748,7 @@ function createCodingAgentModelSync({
         && (session.model_id !== model.model_id || session.model_provider !== model.model_provider);
       if (agentType === 'claude' && model) claudeResolved += 1; if (modelChanged && session.model_id && String(session.model_source || '') === 'db:restore') repairedStamps += 1; // I-6: ONLY a stamp still carrying the pre-apply db:restore provenance is a repair; a mid-session /model switch on a live-sourced row is a normal change
       const truthChanged = _claudeTruthNeedsApply(session, truth);
-      const needsTitleDecision = agentType === 'codex' && session._codexTitleSynced !== true;
+      const needsTitleDecision = agentType === 'codex'; // WP-4/D-10: a title decision is taken on every probe, never once
       // Codex: the effort of the rollout's latest turn_context (observed, never requested).
       const codexEffortChanged = agentType === 'codex' && result.modelEffort !== undefined
         && String(session.model_effort || '') !== String(result.modelEffort || '');
@@ -853,7 +843,9 @@ function createCodingAgentModelSync({
               changed = true;
             }
           }
-          if (entry.titleSynced) session._codexTitleSynced = true;
+          // entry.titleSynced is the batch's "the title decision ran" receipt (the completion cache
+          // below and the durable applier's latch both consume it); the session no longer carries a
+          // one-shot `_codexTitleSynced` gate of its own.
           const complete = (!context.intent.modelId || entry.modelPersisted)
             && (agentType !== 'codex' || entry.titleSynced);
           if (complete) modelSyncState.cacheCompletedContext(context);
@@ -942,5 +934,4 @@ module.exports = {
   opencodeDataDbPath,
   isGenericCodingSessionLabel,
   resolveModelToRegistry,
-  shouldApplyCodexAutoTitle,
 };

package/template/coding-task-manager/lib/coding-session-model-adapters.js

@@ -3,9 +3,28 @@
 // Pure decoders for native provider evidence. These functions deliberately do no discovery or I/O.
 const SYNTHETIC = '<synthetic>';
 const { CLAUDE_ALIASES } = require('./claude-model-selection-vocabulary');
+const { WORKER_MODEL_ALIAS } = require('./model-proxy/lead-worker-picks');
 const ALIASES = new Set([...CLAUDE_ALIASES, 'default']);
 const GEMINI_ALIASES = new Set(['auto', 'default', 'pro', 'flash', 'flash-lite']);
 
+/*
+ * The ONE reserved delegate alias (WORKER_MODEL_ALIAS in lib/model-proxy/lead-worker-picks.js). It names
+ * what a lead's SUBAGENTS ask the proxy for -- never a model a session's own CLI runs -- so it is
+ * refused by VALUE (trimmed, case-insensitive) before any producer can hand it to the ledger as a
+ * lead fact. Normal CLI aliases and policies keep their existing behavior.
+ *
+ * The value is normalised through the SAME one marker rule `modelClass` applies below:
+ * The reserved alias with `[1m]` is wearing the session's context marker, not a different
+ * model, so it can never be a lead fact either. Exactly one marker, and no blacklist of lookalikes
+ * (lookalikes, `claude-opus-5-5[1m]` and every real id keep their existing behavior).
+ */
+function isReservedWorkerModel(value) {
+  if (typeof value !== 'string') return false;
+  const folded = value.trim().toLowerCase();
+  const base = folded.endsWith('[1m]') ? folded.slice(0, -4) : folded;
+  return base === WORKER_MODEL_ALIAS;
+}
+
 function bounded(value, required = false) {
   if (typeof value !== 'string') return null;
   const valueTrimmed = value.trim();
@@ -46,6 +65,7 @@ function emit(out, args) { const item = observation(...args); if (item) out.push
 function modelClass(raw) {
   const name = bounded(raw, true);
   if (!name) return null;
+  if (isReservedWorkerModel(name)) return null;
   const suffix = name.toLowerCase().endsWith('[1m]') ? '[1m]' : '';
   const base = suffix ? name.slice(0, -4) : name;
   const folded = base.toLowerCase();
@@ -165,7 +185,9 @@ function codexSettingsCandidate(owner, rec, index, resumeId) {
   if (rec.type !== 'event_msg' || p.type !== 'thread_settings_applied' || !p.thread_id ||
       (p.thread_id !== owner.providerSessionId && p.thread_id !== resumeId) || !p.thread_settings) return null;
   const model = bounded(p.thread_settings.model, true);
-  if (!model) return null;
+  // Codex carries the same reserved alias in its thread settings and turn contexts when a lead's
+  // subagents are routed through the proxy; neither can be the lead's own model (AC-0d).
+  if (!model || isReservedWorkerModel(model)) return null;
   const ordinal = Number.isSafeInteger(rec.ordinal) && rec.ordinal >= 0 ? String(rec.ordinal) : null;
   return { at: time(rec.timestamp), index, value: model, effort: p.thread_settings.reasoning_effort ?? null,
     sourceRevision: ordinal, source: 'codex:thread-settings' };
@@ -186,6 +208,7 @@ function codexTurnContextCandidate(owner, rec, index, resumeId) {
   if (!(rec.type === 'turn_context' || (rec.type === 'event_msg' && p.type === 'turn_context'))) return null;
   const model = bounded(p.model ?? p.model_id, true);
   const turnId = p.turn_id == null ? null : String(p.turn_id);
+  if (isReservedWorkerModel(model)) return null;
   return { at: time(rec.timestamp), index, payload: p, model, turnId };
 }
 
@@ -297,4 +320,6 @@ module.exports = { claudeModelObservations, claudeHookModelObservations, codexMo
   laterRank: later, isCodexRelatedRecord, codexThreadMatches,
   claudeIdentityCandidate, claudeTurnCandidate, claudeIdentityObservations, claudeTurnObservations,
   codexSettingsCandidate, codexSettingsObservations, codexTurnContextCandidate, codexTerminalCandidate,
-  codexTurnObservations };
+  codexTurnObservations,
+  // WP-0: the one shared "is this the reserved delegate alias?" predicate (see the doc comment above).
+  isReservedWorkerModel };

package/template/coding-task-manager/lib/coding-session-model-projection.js

@@ -1,11 +1,16 @@
 'use strict';
 
+const { isReservedWorkerModel } = require('./coding-session-model-adapters');
+
 const PRIORITY = Object.freeze({ resolved: 3, lastCompletedTurn: 2, selection: 1 });
 const MODEL_RESULT_PAGE_SIZE = 8;
 const MAX_MODEL_RESULT_BYTES = 1024 * 1024;
 
 function concrete(fact, allowNullKind) {
   return !!fact && typeof fact.value === 'string' && fact.value.trim() !== '' && Buffer.byteLength(fact.value.trim(), 'utf8') <= 256 && !fact.value.includes('<synthetic>') && Number.isFinite(fact.observedAtMs) && fact.observedAtMs >= 0 &&
+    // WP-0 (AC-0c): a historical row may still HOLD the reserved alias (it is kept for audit), but it
+    // is never a compatibility model -- the real selection/turn wins by the existing precedence below.
+    !isReservedWorkerModel(fact.value) &&
     (fact.selectionKind === 'concrete' || (allowNullKind && fact.selectionKind === null));
 }
 

package/template/coding-task-manager/lib/coding-session-model-runtime.js

@@ -1470,7 +1470,7 @@ function createDurableModelResultApplier({ modelStateRuntime, isCurrent, isOwner
       context.capturedSignature = refreshSignature(context.session, context.agentType);
       if (context.agentType === 'opencode' && context.result.sourceRevision) context.nextSourceRevision = String(context.result.sourceRevision);
       cacheCompleted(context);
-      if (context.agentType === 'codex' && context.session._codexTitleSynced !== true) {
+      if (context.agentType === 'codex') { // WP-4/D-10: the thread name is decided on every completed probe, never once
         context.needsTitleDecision = true;
         intents.push({ id: context.session.id, agentType: 'codex', generation, capturedSignature: context.capturedSignature,
           agentSessionId: context.ownerSnapshot.providerSessionId, liveLabel: normalizeTitle(context.session.label),
@@ -1488,7 +1488,6 @@ function createDurableModelResultApplier({ modelStateRuntime, isCurrent, isOwner
       const entry = byId.get(String(context.session.id));
       if (!entry || Number(entry.generation) !== generation || entry.capturedSignature !== context.capturedSignature) continue;
       if (entry.titleApplied && entry.title && entry.titleKind !== 'live') { const label = `Codex: ${entry.title}`; if (context.session.label !== label) { context.session.label = label; titleChanged = true; } }
-      if (entry.titleSynced) context.session._codexTitleSynced = true;
       if (entry.titleSynced) cacheCompleted(context);
     }
     if (titleChanged && typeof broadcastSessionList === 'function') broadcastSessionList();

package/template/coding-task-manager/lib/coding-session-model-state.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { isReservedWorkerModel } = require('./coding-session-model-adapters');
+
 const SOURCE_GROUPS = {
   claude: {
     selection: ['hook:PostModelSwitch', 'hook:SessionStart', 'transcript:identity', 'db:restore'],
@@ -54,6 +56,14 @@ function validateObservation(input) {
     if (fields.outcome !== 'completed' || fields.value === null || fields.selectionKind !== 'concrete') return null;
   }
   if (fields.kind === 'selection' && ['alias', 'policy'].includes(fields.selectionKind) && fields.value === null) return null;
+  /*
+   * WP-0 (AC-0b): the reserved delegate alias is refused by VALUE for every kind, whatever
+   * selectionKind a caller claims for it -- a lead session's own model can never be what its
+   * subagents ask the proxy for. `validFact`/`validPrior` deliberately stay permissive, so a row
+   * already persisted with the alias still loads (the projection skips the fact; history is never
+   * rewritten or dropped).
+   */
+  if (isReservedWorkerModel(fields.value)) return null;
   return { ...fields, processGeneration: input.processGeneration, observedAtMs: input.observedAtMs };
 }
 

package/template/coding-task-manager/lib/coding-session-model-sync-state.js

@@ -127,7 +127,6 @@ function createCodingSessionModelSyncState({
       String(session?.model_source || ''),
       Number(session?.model_observed_at || 0),
       String(session?.label || ''),
-      session?._codexTitleSynced === true,
       String(session?._claudeSessionId || session?.agentSessionId || ''),
       /*
        * Corrective finding 10: the PURE provider-source inputs a checkpoint's offsets are relative to.

package/template/coding-task-manager/lib/conversation-import/cursor-guard-owner.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const path = require('path');
 const { ANCHOR_PREFIX, cursorAnchorGuard } = require('./source-checkpoint');
 
 // WP-1 (design D-3/D-4): the conversation cursor is an anchor guard and nothing else.
@@ -77,13 +78,22 @@ function commitConversationBatchAndTranscriptCursor(db, options) {
        OR transcript_files.status IS NOT 'ok'
        OR transcript_files.last_error IS NOT ''
   `);
+  // A row's `ctm_session_id` changing under this upsert used to be silent -- one committed import
+  // re-keys the file to a different owner (a re-import of the same rollout under another session)
+  // with nothing in the log to say so. Read the prior owner inside the transaction, before the write.
+  const readPriorOwner = db.prepare('SELECT ctm_session_id FROM transcript_files WHERE jsonl_path = ?');
   return db.transaction(() => {
+    const priorOwner = readPriorOwner.get(options.filePath);
     const committed = options.commitBatch(db, options.batch);
     // WP-1 (S-3b): the guard is stored as-is; the manifest receipt binding is deleted with
     // the whole-prefix proof it fenced.
     upsert.run(options.filePath, options.agentSessionId, options.ctmSessionId, options.provider,
       String(options.stat.dev ?? ''), String(options.stat.ino ?? ''), Number(options.stat.size || 0),
       Number(options.stat.mtimeMs || 0), options.offset, options.parserVersion, options.guard);
+    // One line, ids only (truncated). The basename, never the full path, and never any content.
+    const prior = priorOwner ? String(priorOwner.ctm_session_id || '') : '';
+    const next = String(options.ctmSessionId || '');
+    if (priorOwner && prior !== next) console.log(`[transcript-owner] cursor commit changed owner ${path.basename(String(options.filePath || ''))}: ${prior.slice(0, 8)} -> ${next.slice(0, 8)}`);
     return committed;
   })();
 }