create-walle 0.10.0 → 0.10.1

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/db-owner-worker-client.js

@@ -937,12 +937,34 @@ class CtmDbOwnerWorkerClient {
     }).catch(() => {});
   }
 
+  // WP-A P-2 (freeze-probes): the up-to-`limit` OLDEST client requests still outstanding on this
+  // worker, each { op, ageMs, started } -- what a memory step should be read against. One pass over
+  // the Map with a bounded insert (never a sort of the whole pending set: this runs on the sampler path).
+  _oldestPendingOps(limit = 5) {
+    const now = Date.now();
+    const oldest = [];
+    for (const pending of this._pending.values()) {
+      const entry = {
+        op: String(pending?.op || 'unknown'),
+        ageMs: Math.max(0, now - (Number(pending?.enqueuedAt) || now)),
+        started: Number(pending?.startedAt) > 0,
+      };
+      let at = oldest.length;
+      while (at > 0 && oldest[at - 1].ageMs < entry.ageMs) at -= 1;
+      if (at >= limit) continue;
+      oldest.splice(at, 0, entry);
+      if (oldest.length > limit) oldest.pop();
+    }
+    return oldest;
+  }
+
   getStatus() {
     const s = {
       ...this._status,
       ready: this._ready,
       closed: this._closed,
       pendingClientRequests: this._pending.size,
+      pendingOps: this._oldestPendingOps(),
       degraded: this.isDegraded(),
       degradedUntil: this._degradedUntil,
       consecutiveTimeouts: this._consecutiveTimeouts,

package/template/coding-task-manager/lib/feature-manifest.js

@@ -612,8 +612,6 @@ const FEATURES = [
   { id: "ctm_ctm_fp_memo", env: "CTM_FP_MEMO", owner: "ctm-core-team", stage: "stable", defaultOn: true, since: "2026-08-24", expires: null },
   // !== '0' comparison found; 1 site(s); first: lib/ws/state-sync.js:470
   { id: "ctm_ctm_frame_nack", env: "CTM_FRAME_NACK", owner: "ctm-core-team", stage: "stable", defaultOn: true, since: "2026-08-24", expires: null },
-  // !== '0' comparison found; 1 site(s); first: server.js:36110
-  { id: "ctm_ctm_freeze_park_giant", env: "CTM_FREEZE_PARK_GIANT", owner: "ctm-core-team", stage: "stable", defaultOn: true, since: "2026-08-24", expires: null },
   // numeric-tunable suffix/read shape; 1 site(s); first: lib/perf-tracker.js:829
   { id: "ctm_ctm_freeze_probe_ms", env: "CTM_FREEZE_PROBE_MS", owner: "ctm-core-team", stage: "ops", tunable: true, default: 0, since: "2026-08-24", expires: null, note: "numeric tunable" },
   // !== '0' comparison found; 1 site(s); first: server.js:445

package/template/coding-task-manager/lib/harness-history-transition.js

@@ -5,7 +5,13 @@ const KNOWN_ORIGINS = new Set([...NATIVE_ORIGINS, 'routed-proxy', 'portable-tran
 // S-3: the adapter/schema ids and the version membership test come from the one qualified table.
 const { CODEX_CONTROL_ADAPTER, CODEX_COMPACTION_SCHEMA_RECEIPT, CODEX_PRE_TURN_COMPACTION_SCHEMA,
   isQualifiedCodexVersion } = require('./codex-harness-qualification');
-const PORTABLE_HISTORY_KINDS = new Set(['text', 'tool-pair', 'native-world-state', 'native-lifecycle']);
+// S-4: the ONE portable-kind set. `native-media` is a message whose only non-text content parts are
+// input_image parts (D-2); it is portable only to a Codex target, which is the planner's job below.
+const PORTABLE_HISTORY_KINDS = new Set(['text', 'tool-pair', 'native-world-state', 'native-lifecycle', 'native-media']);
+// D-5/D-6 (docs/codex-lead-routed-switch-history-handoff-2026-10-21.html §6.2): the plaintext handoff
+// the source model writes is injected into the forked target, so it consumes target context that the
+// source estimate does not count. 32 KiB of summary text is 8_192 tokens at four characters each.
+const HANDOFF_TOKEN_RESERVE = 8_192;
 
 function inspectTransition({ sourceRecipe, targetRecipe, snapshot, signal } = {}) {
   if (signal?.aborted) return refuse('transition_cancelled');
@@ -17,9 +23,11 @@ function inspectTransition({ sourceRecipe, targetRecipe, snapshot, signal } = {}
   const targetProviderId = nonempty(targetRecipe.providerId);
   const origin = nonempty(sourceRecipe.origin);
   const codexHistorySource = origin === 'native-codex' || sourceRecipe.harness === 'codex-cli';
+  // D-3: qualification is per record (D-1) plus the installed binary that performs the fork. The
+  // rollout's CREATOR version (session_meta.cli_version, written once at creation) is not the writer
+  // of its later records, so it is not a gate here.
   const qualifiedCodexHistorySource = codexHistorySource
-    && sourceRecipe.controlAdapterVersion === CODEX_CONTROL_ADAPTER
-    && isQualifiedCodexVersion(sourceRecipe.programVersion);
+    && sourceRecipe.controlAdapterVersion === CODEX_CONTROL_ADAPTER;
   if (!origin) return refuse('source_origin_unknown');
   if (!KNOWN_ORIGINS.has(origin)) return refuse('source_origin_unsupported');
   if (!sourceProviderId || !targetProviderId) return refuse('provider_identity_unknown');
@@ -31,7 +39,7 @@ function inspectTransition({ sourceRecipe, targetRecipe, snapshot, signal } = {}
   if (nativeSource && sourceProviderId === targetProviderId) {
     return {
       action: 'reuse', reason: 'same_provider_native_history', sourceCheckpoint,
-      estimateTokens, targetBudgetTokens: null, evidenceKind,
+      estimateTokens, targetBudgetTokens: null, evidenceKind, handoff: null,
     };
   }
 
@@ -40,12 +48,8 @@ function inspectTransition({ sourceRecipe, targetRecipe, snapshot, signal } = {}
   if (!sourceCheckpoint) return refuse('source_checkpoint_unknown');
   if (codexHistorySource && sourceProviderId !== targetProviderId
       && (!qualifiedCodexHistorySource
-        || !isQualifiedCodexVersion(sourceRecipe.programVersion)
         || sourceRecipe.cyberAccessProgram !== null
         || snapshot.previousSettings?.cyberAccessProgram !== null
-        || (snapshot.previousSettings?.programVersion !== undefined
-          && snapshot.previousSettings?.programVersion !== null
-          && !isQualifiedCodexVersion(snapshot.previousSettings.programVersion))
         || targetRecipe.harness !== 'codex-cli' || !isQualifiedCodexVersion(targetRecipe.harnessVersion))) {
     return refuse('native_fork_adapter_unqualified', { sourceCheckpoint });
   }
@@ -71,7 +75,27 @@ function inspectTransition({ sourceRecipe, targetRecipe, snapshot, signal } = {}
     }
   }
   if (snapshot.opaque === true || has(snapshot.historyKinds, 'opaque')) return refuse('opaque_history_not_portable', { sourceCheckpoint });
-  if (snapshot.compacted === true) return refuse('compacted_source_fork_unqualified', { sourceCheckpoint });
+  // D-2: native media is portable exactly when the target is Codex, which strips images the target
+  // cannot accept (core/src/context_manager/normalize.rs:346 @ rust-v0.163.0). A non-Codex target
+  // gets a plain refusal instead of a silent rewrite of the source history.
+  if (has(snapshot.historyKinds, 'native-media') && targetRecipe.harness !== 'codex-cli') {
+    return refuse('history_media_not_portable', { sourceCheckpoint });
+  }
+  // D-5/D-6: a sealed `compaction` item is carried by a plaintext handoff the SOURCE model writes
+  // before the switch. Exactly one sealed digest can be covered, and only the native openai source
+  // (whose own model can be asked to write it) can produce one; everything else keeps a named refusal.
+  const sealed = (Array.isArray(snapshot.encryptedCompactions) ? snapshot.encryptedCompactions : [])
+    .filter((sha) => typeof sha === 'string' && /^[a-f0-9]{64}$/.test(sha));
+  if (sealed.length > 1) return refuse('encrypted_compaction_multiple', { sourceCheckpoint });
+  const handoff = sealed.length === 1 && snapshot.handoffCovers !== true
+    ? (qualifiedCodexHistorySource && origin === 'native-codex' && sourceProviderId === 'openai'
+      ? { required: true, compactionSha256: sealed[0] } : null)
+    : null;
+  if (sealed.length === 1 && snapshot.handoffCovers !== true && !handoff) {
+    return refuse('encrypted_compaction_handoff_unavailable', { sourceCheckpoint });
+  }
+  // D-4: a plaintext compaction is portable. Codex fork rebuilds the window from
+  // replacement_history, and no test, doc or incident ever justified the blanket refusal.
   if (snapshot.encrypted === true || has(snapshot.historyKinds, 'encrypted')) return refuse('encrypted_history_not_portable', { sourceCheckpoint });
   if (!Array.isArray(snapshot.historyKinds) || snapshot.historyKinds.length === 0
       || snapshot.historyKinds.some((kind) => !PORTABLE_HISTORY_KINDS.has(kind))) {
@@ -126,7 +150,10 @@ function inspectTransition({ sourceRecipe, targetRecipe, snapshot, signal } = {}
     : null;
   const evidence = { sourceCheckpoint, estimateTokens, targetBudgetTokens, evidenceKind,
     ...(preTurnCompaction ? { preTurnCompaction } : {}) };
-  if (estimateTokens <= targetBudgetTokens) return { action: 'reuse', reason: 'history_fits_target', ...evidence };
+  // The injected handoff is target context the source estimate cannot see, so the comparison
+  // reserves it while every reported evidence field keeps the measured source value.
+  const budgetTokens = handoff?.required ? estimateTokens + HANDOFF_TOKEN_RESERVE : estimateTokens;
+  if (budgetTokens <= targetBudgetTokens) return { action: 'reuse', reason: 'history_fits_target', ...evidence, handoff };
 
   // Phase A has no qualified source-owned compact adapter. Native API acknowledgements alone
   // are not durable checkpoint receipts, so a recipe flag cannot authorize mutation here.
@@ -191,4 +218,4 @@ function refuse(reason, details = {}) {
   return { action: 'unsupported', reason, ...details };
 }
 
-module.exports = { inspectTransition, computeTargetBudget };
+module.exports = { inspectTransition, computeTargetBudget, PORTABLE_HISTORY_KINDS, HANDOFF_TOKEN_RESERVE };

package/template/coding-task-manager/lib/headless-term-service.js

@@ -1345,6 +1345,8 @@ async function handleMessage(msg) {
           // WP-0b (§6): the xterm write callback for THIS feed -- exactly where the brief says
           // `mirror-written` belongs.
           _noteWorkerTypingStagePending(msg.sessionId, entry, 'mirror-written');
+          // WP-3 (D-C2): per-key shadow echo matchers -- see lib/typing-worker-stages.js.
+          _typingWorkerStages.matchEchoPredictions(postTransport, msg.sessionId, entry, msg.data);
           entry.state.liveOutputSeq += 1;
           entry.state.liveBytesSinceSeed += byteCount;
           if (entry.state.pendingInputSeq > entry.state.echoedThroughInputSeq) {
@@ -1470,12 +1472,9 @@ async function handleMessage(msg) {
       // every keystroke (HeadlessTerminalRouter.postMessage, lib/session-host-manager.js
       // :1815-1834, forwards by sessionId to the pool host when one owns the session, else the
       // legacy worker thread) -- carry the pending typing-interaction ids here, not on 'feed'.
-      if (Array.isArray(msg.interactionIds) && msg.interactionIds.length) {
-        entry.state.pendingTypingInteractionIds = _typingWorkerStages.mergePendingInteractionIds(
-          entry.state.pendingTypingInteractionIds, msg.interactionIds,
-        );
-        entry.state.typingIdsAwaitingFeed = true;
-      }
+      // WP-3 (D-C2): the pending-id merge above moved into armEchoPrediction, which also arms
+      // this keystroke's shadow echo prediction when the message carries one.
+      _typingWorkerStages.armEchoPrediction(entry, msg);
       break;
     }