create-walle 0.10.2 → 0.10.3

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

@@ -1,6 +1,9 @@
 'use strict';
 
 const { reduceModelObservation, validateModelState } = require('../coding-session-model-state');
+// WP-8 (deepseek-harness-acp-agent §9b M-9): the owner agent-type list is the ONE declaration in
+// lib/coding-session-model-owner.js — this module keeps no private copy of it.
+const { OWNER_AGENT_TYPES } = require('../coding-session-model-owner');
 const { compatibilityModelFact } = require('../coding-session-model-projection');
 const { readLaunchGenerationRow, applyGenerationAdoption } = require('./coding-session-generation-store');
 
@@ -27,7 +30,7 @@ function createCodingSessionModelStore({ getCoreDb, tableExists, projectCompatib
     return decode(select(db, String(ctmSessionId || '').trim()));
   };
   const ownerValid = (owner) => owner && typeof owner.ctmSessionId === 'string' && owner.ctmSessionId.trim() === owner.ctmSessionId && Buffer.byteLength(owner.ctmSessionId, 'utf8') > 0 && Buffer.byteLength(owner.ctmSessionId, 'utf8') <= 256 &&
-    ['claude', 'codex', 'gemini', 'opencode'].includes(owner.agentType) &&
+    OWNER_AGENT_TYPES.includes(owner.agentType) &&
     typeof owner.providerSessionId === 'string' && owner.providerSessionId.trim() === owner.providerSessionId && Buffer.byteLength(owner.providerSessionId, 'utf8') > 0 && Buffer.byteLength(owner.providerSessionId, 'utf8') <= 256 &&
     Number.isSafeInteger(owner.processGeneration) && owner.processGeneration >= 0;
   const ownerRow = (db, owner) => db.prepare(`

package/template/coding-task-manager/lib/storage/delegate-pref-mirror-store.js

@@ -17,7 +17,7 @@
 const { isValidEffort } = require('../launch-model-override');
 
 const MAX_FIELD_LENGTH = 200;
-const AGENTS = new Set(['claude', 'codex']);
+const AGENTS = new Set(['claude', 'codex', 'opencode']);
 const LANES = new Set(['native', 'routed', 'inherit']);
 const LAUNCH_KINDS = new Set(['none', 'native', 'inherit', 'routed', 'unservable']);
 const MIRROR_TABLE = 'delegate_pref_mirror';
@@ -44,6 +44,19 @@ function _normalizeEffort(effort) {
   throw new TypeError("effort must be null, '' or a bounded effort identifier");
 }
 
+// v58 (WP-1, codex-native-subagent-pick-enforcement-2026-10-28.html §5 D-4, §6): the launch row also
+// records what the spawn DID about Codex native sub-agents. Exactly two known states plus unknown:
+//   null       = unknown (no fact recorded, i.e. every pre-v58 row)
+//   ''         = this launch did NOT deny native sub-agents
+//   'disabled' = this launch carried CODEX_NATIVE_SUBAGENT_DENY_ARGS
+// A non-string or any other token is refused here rather than stored, so a read can never report a
+// malformed value as the deny fact.
+function _normalizeNativeSubagents(value) {
+  if (value === null || value === undefined) return null;
+  if (value === '' || value === 'disabled') return value;
+  throw new TypeError("nativeSubagents must be null, '' or 'disabled'");
+}
+
 function createDelegatePrefMirrorStore({ getCoreDb, tableExists, flushWal = () => {}, now = () => new Date().toISOString() } = {}) {
   if (typeof getCoreDb !== 'function' || typeof tableExists !== 'function') throw new TypeError('getCoreDb and tableExists are required');
 
@@ -161,6 +174,9 @@ function createDelegatePrefMirrorStore({ getCoreDb, tableExists, flushWal = () =
       // Absent (pre-v50) is NULL = unknown; a stored '' is the separate "known NO role effort
       // override" state. Read verbatim -- the projection decides what a kind/agent may claim.
       effort: row.effort == null ? null : row.effort,
+      // v58 (WP-1): what this launch DID about Codex native sub-agents. Absent (pre-v58) is NULL =
+      // unknown; read verbatim, so a malformed stored value never becomes a claim.
+      native_subagents: row.native_subagents == null ? null : row.native_subagents,
     };
   }
 
@@ -168,18 +184,24 @@ function createDelegatePrefMirrorStore({ getCoreDb, tableExists, flushWal = () =
     const sessionId = _str(ctmSessionId);
     if (!sessionId || !tableExists(LAUNCH_TABLE)) return null;
     return toLaunchRow(getCoreDb().prepare(
-      'SELECT ctm_session_id, agent, kind, model, source, origin, reason, route_id, launched_at, process_generation, harness, provider_thread_id, effort FROM session_subagent_pick_launch WHERE ctm_session_id = ?'
+      'SELECT ctm_session_id, agent, kind, model, source, origin, reason, route_id, launched_at, process_generation, harness, provider_thread_id, effort, native_subagents FROM session_subagent_pick_launch WHERE ctm_session_id = ?'
     ).get(sessionId));
   }
 
   function setLaunch({ ctmSessionId, agent, kind, model = '', source = '', origin = '', reason = '', routeId = '',
-    processGeneration, harness, providerThreadId, launchedAt, effort = null } = {}) {
+    processGeneration, harness, providerThreadId, launchedAt, effort = null, nativeSubagents = null } = {}) {
     const sessionId = _str(ctmSessionId).trim();
     if (!sessionId) throw new TypeError('ctmSessionId is required');
-    if (!AGENTS.has(agent)) throw new TypeError("agent must be 'claude' or 'codex'");
+    if (!AGENTS.has(agent)) throw new TypeError("agent must be 'claude', 'codex' or 'opencode'");
     if (!LAUNCH_KINDS.has(kind)) throw new TypeError('kind must be none, native, inherit, routed or unservable');
     const effortValue = _normalizeEffort(effort);
-    const expectedHarness = agent === 'claude' ? 'claude-code' : 'codex-cli';
+    const nativeSubagentsValue = _normalizeNativeSubagents(nativeSubagents);
+    // Only Codex has its own harness label. An 'opencode' lead owns its launch row under the same
+    // non-Codex label Claude uses: CTM's owner tuple (generation/harness/thread, see
+    // subagent-pick-table._launchOwnerContext and deleteOwnedLaunch) has exactly two values, and an
+    // OpenCode lead has no lead-route token to conflict with either. Per-launch model projection for
+    // OpenCode is env-only (OPENCODE_CONFIG_CONTENT), so there is no third harness to add here.
+    const expectedHarness = agent === 'codex' ? 'codex-cli' : 'claude-code';
     if (!Number.isSafeInteger(processGeneration) || processGeneration < 1) {
       throw new TypeError('processGeneration must be a positive integer');
     }
@@ -213,15 +235,16 @@ function createDelegatePrefMirrorStore({ getCoreDb, tableExists, flushWal = () =
       db.prepare(
         `INSERT INTO session_subagent_pick_launch
            (ctm_session_id, agent, kind, model, source, origin, reason, route_id, launched_at,
-            process_generation, harness, provider_thread_id, effort)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            process_generation, harness, provider_thread_id, effort, native_subagents)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT(ctm_session_id) DO UPDATE SET agent = excluded.agent, kind = excluded.kind,
            model = excluded.model, source = excluded.source, origin = excluded.origin,
            reason = excluded.reason, route_id = excluded.route_id, launched_at = excluded.launched_at,
            process_generation = excluded.process_generation, harness = excluded.harness,
-           provider_thread_id = excluded.provider_thread_id, effort = excluded.effort`
+           provider_thread_id = excluded.provider_thread_id, effort = excluded.effort,
+           native_subagents = excluded.native_subagents`
       ).run(sessionId, agent, kind, fields.model, fields.source, fields.origin, fields.reason,
-        fields.routeId, launched, processGeneration, harness, threadId, effortValue);
+        fields.routeId, launched, processGeneration, harness, threadId, effortValue, nativeSubagentsValue);
       return getLaunch(sessionId);
     });
     const result = run();

package/template/coding-task-manager/lib/structured-session-boot-sweep.js

@@ -0,0 +1,235 @@
+'use strict';
+
+// Boot sweep for CTM's non-PTY ("structured") sessions. Extracted verbatim from server.js (design
+// doc docs/deepseek-harness-acp-agent-2026-10-28.html §7 offset (3), §9 S-42) so server.js keeps its
+// zero-headroom line count while the same sweep can later also close out an interrupted DeepSeek
+// Harness turn (WP-5 adds that strategy next to the Wall-E one below).
+//
+// WP-V2 A4 — boot sweep. Incident class B: a Wall-E turn that died mid-retry across a restart writes
+// NO terminal record, so the durable transcript permanently looks "running"
+// (walle-interrupted-visibility-resume-design-2026-07-17.html §2.2 V6). Closes those out at the next
+// boot: bounded to walle sessions active in the last 7 days, off the main thread for both the recency
+// check and the jsonl read (reuses the SAME read-pool ops the restore-interruption detector already
+// uses), never a synchronous DB query, and scheduled by server.js via the existing
+// _scheduleAfterStartupMaintenanceQuiet deferral so it never competes with the restore storm on the
+// boot critical path.
+//
+// Every server global the two functions use arrives as a dep; the two limit values (one of them
+// env-derived) are read in server.js because the flag lint forbids new raw process.env reads here.
+//
+// WP-5 (§5 D-9, §9 S-42) adds the DeepSeek Harness strategy beside the Wall-E one. A dsh turn that was
+// in flight when CTM went down wrote its user row and nothing after it, so the durable transcript
+// permanently looks "running". At the next boot the dsh strategy re-reads that transcript off-thread,
+// and — when the last row is a `user` row — appends exactly ONE `dsh_turn_interrupted` row through the
+// SAME writer the live path uses (append-only, async, ordered). Since WP-7d that row is
+// `assistant`-shaped (an API-error row) so Conv renders it. It is naturally
+// idempotent: the row it writes is itself terminal, so a second sweep finds nothing open.
+
+const { createDshTranscriptWriter, dshTranscriptDir, findOpenDshTurn } = require('./acp/dsh-transcript');
+const path = require('node:path');
+
+/**
+ * @param {object} deps
+ * @param {Map} deps.sessions
+ * @param {Function} deps.offthreadRead                 // server.js _offthreadRead
+ * @param {object} deps.restoreInterruptionBreaker
+ * @param {Function} deps.findLastWalleTurnTerminal
+ * @param {Function} deps.detectOpenWalleTurn
+ * @param {Function} deps.appendWalleTurnTerminal       // server.js _appendWalleTurnTerminal
+ * @param {object} deps.runtimeWorkRegistry
+ * @param {Function} deps.statFilesOffThread            // server.js _statFilesOffThread
+ * @param {number} deps.maxSessions
+ * @param {number} deps.maxAgeMs
+ * @param {Function} [deps.getDataDir]                  // WP-5: lib/data-dir.js's getDataDir()
+ * @param {Function} [deps.log]
+ * @param {Function} [deps.warn]
+ * @param {Function} [deps.error]
+ */
+function createStructuredSessionBootSweep(deps = {}) {
+  const {
+    sessions,
+    offthreadRead,
+    restoreInterruptionBreaker,
+    findLastWalleTurnTerminal,
+    detectOpenWalleTurn,
+    appendWalleTurnTerminal,
+    runtimeWorkRegistry,
+    statFilesOffThread,
+    maxSessions,
+    maxAgeMs,
+    getDataDir,
+    log = (...args) => console.log(...args),
+    warn = (...args) => console.warn(...args),
+    error = (...args) => console.error(...args),
+  } = deps;
+
+  async function sweepWalleSessionOpenTurn(session) {
+    if (!session || !session.jsonlPath || session.abortController) return null;
+    const tail = await offthreadRead({
+      breaker: restoreInterruptionBreaker,
+      op: 'restoreInterruptionTail',
+      payload: { path: session.jsonlPath },
+      timeoutMs: 15000,
+      onSuccess: (res) => res || null,
+      onFail: () => null,
+    });
+    const entries = tail && Array.isArray(tail.entries) ? tail.entries : null;
+    if (!entries || !entries.length) return null;
+    const lastTerminal = findLastWalleTurnTerminal(entries);
+    if (lastTerminal) {
+      session._walleLastTurnTerminal = lastTerminal;
+      session._walleTurnTerminalWrittenFor = lastTerminal.turnId || '';
+    }
+    const openTurn = detectOpenWalleTurn(entries);
+    if (!openTurn.open) return null;
+    // Re-check liveness right before writing — this session's off-thread tail read may
+    // have raced a fresh turn starting (auto-resume, a queued send) while it was in
+    // flight. Never slam the door on a turn that's actually running.
+    if (session.abortController) return null;
+    const appended = appendWalleTurnTerminal(session, openTurn.turnId, {
+      status: 'interrupted_infra',
+      reason: 'boot_sweep_open_turn',
+      source: 'boot_sweep',
+      detectedBy: 'boot_sweep',
+      message: 'Wall-E restarted before this turn finished — nothing is running now.',
+      lastActivityAt: openTurn.lastActivityAt || '',
+    });
+    if (!appended) return null;
+    const retired = runtimeWorkRegistry.retireTurnWithoutHydration({
+      sessionId: session.id,
+      turnId: openTurn.turnId,
+      status: 'stopped',
+      summary: 'Interrupted by CTM restart',
+    });
+    if (retired?.persisted && typeof retired.persisted.then === 'function') {
+      await retired.persisted;
+    }
+    return appended;
+  }
+
+  async function runWalleBootTurnSweep() {
+    try {
+      const candidates = [];
+      for (const session of sessions.values()) {
+        if (session && session.type === 'walle' && session.jsonlPath) candidates.push(session);
+        if (candidates.length >= maxSessions) break;
+      }
+      if (!candidates.length) return;
+      const stats = await statFilesOffThread(candidates.map((s) => s.jsonlPath), 20000);
+      if (!stats) {
+        warn('[walle-boot-sweep] off-thread stat unavailable — skipping this boot (next boot retries).');
+        return;
+      }
+      const cutoff = Date.now() - maxAgeMs;
+      const recent = candidates.filter((session) => {
+        const st = stats.get(session.jsonlPath);
+        return st && st.exists && Number(st.mtimeMs || 0) >= cutoff;
+      });
+      let closed = 0;
+      for (const session of recent) {
+        try {
+          const result = await sweepWalleSessionOpenTurn(session);
+          if (result) closed += 1;
+        } catch (e) {
+          error('[walle-boot-sweep] session sweep failed:', session.id, e && e.message);
+        }
+      }
+      if (recent.length) {
+        log(`  [walle-boot-sweep] checked ${recent.length} recent Wall-E session(s); closed ${closed} silently-open turn(s).`);
+      }
+    } catch (e) {
+      error('[walle-boot-sweep] failed:', e && e.message);
+    }
+  }
+
+  // The transcript a dsh session's rows live in: the placeholder's own `jsonlPath` when the restore
+  // loop set one, else the D-8 path derived from the stored ACP session id.
+  function transcriptPathForDsh(session) {
+    if (!session) return '';
+    if (session.jsonlPath) return session.jsonlPath;
+    const acpSessionId = String(session.agentSessionId || (session._restoreTask && session._restoreTask.chat_session_id) || '');
+    if (!acpSessionId || typeof getDataDir !== 'function') return '';
+    return path.join(dshTranscriptDir(getDataDir()), `${acpSessionId}.jsonl`);
+  }
+
+  // One dsh session: read the transcript tail, and close a silently-open turn with ONE interrupted row.
+  async function sweepDshSessionOpenTurn(session) {
+    const jsonlPath = transcriptPathForDsh(session);
+    if (!jsonlPath) return null;
+    // A session whose child is LIVE right now owns its own writer and an actually-running turn; the
+    // sweep only ever closes a turn that died with the CTM process.
+    if (session._dshTranscript) return null;
+    const tail = await offthreadRead({
+      breaker: restoreInterruptionBreaker,
+      op: 'restoreInterruptionTail',
+      payload: { path: jsonlPath },
+      timeoutMs: 15000,
+      onSuccess: (res) => res || null,
+      onFail: () => null,
+    });
+    const entries = tail && Array.isArray(tail.entries) ? tail.entries : null;
+    if (!entries || !entries.length) return null;
+    if (!findOpenDshTurn(entries)) return null;
+    // Re-check liveness right before writing: this session's off-thread tail read may have raced a
+    // fresh wake (attach, queued Send) while it was in flight. Never slam a running turn shut.
+    if (session._dshTranscript) return null;
+    const acpSessionId = String(session.agentSessionId || (session._restoreTask && session._restoreTask.chat_session_id) || '');
+    if (!acpSessionId) return null;
+    // Reopen the SAME file append-only. This writer is throwaway: it exists only to land the one row,
+    // and it re-seeds its parentUuid from the file's own tail so the chain stays unbroken.
+    const writer = createDshTranscriptWriter({
+      dataDir: typeof getDataDir === 'function' ? getDataDir() : '',
+      acpSessionId,
+      cwd: session.cwd || '',
+    });
+    if (typeof writer.appendTurnInterrupted !== 'function') return null;
+    const row = writer.appendTurnInterrupted();
+    if (typeof writer.whenIdle === 'function') await writer.whenIdle();
+    return row || null;
+  }
+
+  async function runDshBootTurnSweep() {
+    try {
+      const candidates = [];
+      for (const session of sessions.values()) {
+        if (session && session.type === 'dsh' && transcriptPathForDsh(session)) candidates.push(session);
+        if (candidates.length >= maxSessions) break;
+      }
+      if (!candidates.length) return;
+      const stats = await statFilesOffThread(candidates.map((s) => transcriptPathForDsh(s)), 20000);
+      if (!stats) {
+        warn('[dsh-boot-sweep] off-thread stat unavailable — skipping this boot (next boot retries).');
+        return;
+      }
+      const cutoff = Date.now() - maxAgeMs;
+      const recent = candidates.filter((session) => {
+        const st = stats.get(transcriptPathForDsh(session));
+        return st && st.exists && Number(st.mtimeMs || 0) >= cutoff;
+      });
+      let closed = 0;
+      for (const session of recent) {
+        try {
+          const result = await sweepDshSessionOpenTurn(session);
+          if (result) closed += 1;
+        } catch (e) {
+          error('[dsh-boot-sweep] session sweep failed:', session.id, e && e.message);
+        }
+      }
+      if (recent.length) {
+        log(`  [dsh-boot-sweep] checked ${recent.length} recent DeepSeek Harness session(s); closed ${closed} silently-open turn(s).`);
+      }
+    } catch (e) {
+      error('[dsh-boot-sweep] failed:', e && e.message);
+    }
+  }
+
+  // The one call server.js makes at boot: both non-PTY strategies, Wall-E first (unchanged order).
+  async function runStructuredBootTurnSweep() {
+    await runWalleBootTurnSweep();
+    await runDshBootTurnSweep();
+  }
+
+  return { runStructuredBootTurnSweep, runWalleBootTurnSweep, sweepWalleSessionOpenTurn, runDshBootTurnSweep, sweepDshSessionOpenTurn };
+}
+
+module.exports = { createStructuredSessionBootSweep };

package/template/coding-task-manager/lib/submission-ack.js

@@ -101,6 +101,85 @@ function queuedWalleRuntimeInputId(item, fallbackInputId = '') {
   return String(fallbackInputId || '');
 }
 
+// IR2 (design doc walle-inflight-readiness-and-replay-2026-10-27.html §5): a caller
+// already joined to another in-process owner must not re-enter admission just because
+// the stored decision still says proceed. Process readiness decides whether re-entry
+// is permitted; the recorded phase decides the reply. Neither outcome certifies a SQL
+// commit, a provider no-post boundary or cancellation authority.
+function classifyInFlightSubmissionDecision(storedDecision, readiness) {
+  // Sent/conflict/read-error decisions are strictly further along than any local
+  // readiness observation and are returned untouched.
+  if (!storedDecision || storedDecision.action !== 'proceed') return storedDecision;
+  // Only a claim given up before its readiness checkpoint preserves the ordinary retry policy.
+  if (readiness === 'released_unready') return storedDecision;
+  // Unknown readiness supplies neither acceptance nor release authority.
+  if (readiness !== 'owner_ready') return { action: 'error', reason: 'dedup_unavailable' };
+  // Exact machine codes from the classifier's own inputs; never a display message,
+  // a suffix parse or a blanket proceed->accepted. Any other phase (pending,
+  // received, orphaned, missing, future) is a reconciliation-unavailable error.
+  switch (storedDecision.reason) {
+    case 'accepted_retry':
+      return { action: 'replay', replayStatus: 'accepted', reason: 'duplicate_replay' };
+    case 'rejected_retry':
+    case 'cancelled_retry':
+      return { action: 'replay', replayStatus: 'failed', reason: 'duplicate_replay' };
+    case 'deferred_retry':
+      return { action: 'replay', replayStatus: 'blocked', reason: 'duplicate_replay', retryable: true };
+    default:
+      return { action: 'error', reason: 'dedup_unavailable' };
+  }
+}
+
+// IR5: the pure stored-response presentation lives here (the frame module), not in
+// server.js -- server.js is at its line ceiling and must not be compressed. None of
+// these messages claim rollback, undo, provider liveness or a safe effect repetition.
+const STORED_SUBMISSION_REPLAY_MESSAGES = Object.freeze({
+  sent: 'Sent (already delivered)',
+  accepted: 'Already accepted - still confirming...',
+  failed: 'The original submission has a recorded unsuccessful outcome. This replay did not start another attempt.',
+  blocked: 'The original submission is recorded as deferred. This replay did not start another attempt.',
+});
+const STORED_SUBMISSION_UNAVAILABLE_MESSAGE =
+  'CTM cannot yet reconcile the original request. This replay has not started an additional attempt.';
+const STORED_SUBMISSION_CONFLICT_MESSAGE =
+  'This submission id was already used for different prompt text.';
+
+function walleStoredSubmissionResponse(decision, source) {
+  const action = decision && typeof decision === 'object' ? decision.action : '';
+  if (
+    action === 'replay'
+    && Object.prototype.hasOwnProperty.call(STORED_SUBMISSION_REPLAY_MESSAGES, String(decision.replayStatus || ''))
+  ) {
+    const status = String(decision.replayStatus || '');
+    return {
+      status,
+      details: {
+        reason: decision.reason,
+        message: STORED_SUBMISSION_REPLAY_MESSAGES[status],
+        signal: status === 'sent' ? 'durable_row' : '',
+        source,
+        retryable: status === 'blocked',
+      },
+      result: { ok: true, deduplicated: true },
+    };
+  }
+  // Conflict keeps its own message; everything else (read error, unreadable phase,
+  // an unknown replay status) is reconciliation-unavailable and stays retryable.
+  const conflict = action === 'conflict';
+  const reason = conflict ? decision.reason : 'dedup_unavailable';
+  return {
+    status: 'blocked',
+    details: {
+      reason,
+      message: conflict ? STORED_SUBMISSION_CONFLICT_MESSAGE : STORED_SUBMISSION_UNAVAILABLE_MESSAGE,
+      signal: '',
+      source,
+      retryable: !conflict,
+    },
+    result: { ok: false, code: reason },
+  };
+}
+
 function createInFlightSubmissionRegistry() {
   const records = new Map();
 
@@ -123,7 +202,7 @@ function createInFlightSubmissionRegistry() {
     const record = records.get(String(key || ''));
     if (!record || record.token !== token || record.resolved) return false;
     record.resolved = true;
-    record.resolveReady();
+    record.resolveReady('owner_ready');
     return true;
   }
 
@@ -131,7 +210,14 @@ function createInFlightSubmissionRegistry() {
     const cleanKey = String(key || '');
     const record = records.get(cleanKey);
     if (!record || record.token !== token) return false;
-    markReady(cleanKey, token);
+    // A claim released before its readiness checkpoint is the ONLY readiness that
+    // permits the caller's ordinary retry policy. A claim already settled as
+    // owner_ready keeps that first settlement (Promise single-assignment); this
+    // deletes its own record and nothing else.
+    if (!record.resolved) {
+      record.resolved = true;
+      record.resolveReady('released_unready');
+    }
     records.delete(cleanKey);
     return true;
   }
@@ -172,11 +258,13 @@ module.exports = {
   CTM_SUBMIT_ACK_TRUTH,
   REMOTE_SUBMISSION_OBSERVE_DELAYS_MS,
   classifyDuplicateSubmission,
+  classifyInFlightSubmissionDecision,
   createInFlightSubmissionRegistry,
   markerEvidence,
   queuedWalleRuntimeInputId,
   redactSubmissionPreview,
   replayStatusForEnvelopeResult,
   walleSubmissionStatusFrame,
+  walleStoredSubmissionResponse,
   walleStoredTurnIdForPrompt,
 };

package/template/coding-task-manager/lib/systemd-scope.js

@@ -0,0 +1,115 @@
+'use strict';
+
+// Session hosts survive a systemd CTM restart (docs/session-host-cgroup-survival-and-durable-jobs-2026-10-31.html
+// §5 D-1..D-6, §6.1). Under ctm.service (KillMode=control-group) a `detached: true` child is still in the
+// unit's cgroup and is reaped when the unit stops. tmux/podman fix this by moving the child into its own
+// transient .scope right after fork (StartTransientUnit with PIDs). We issue the same call through busctl
+// (no Node D-Bus binding is installed) with an argv array -- no shell.
+
+const fs = require('node:fs');
+const { execFile } = require('node:child_process');
+const { registerFlag, boolFlag, createEnvFlags } = require('./env-flags');
+
+registerFlag('CTM_HOST_OWN_SCOPE', {
+  kind: 'bool',
+  default: true,
+  desc: 'On a systemd service host, move each session-host/pool/proxy process into its own transient scope so a CTM restart does not reap it.',
+  expires: null,
+});
+
+// The process-wide singleton reads process.env; a caller-injected env (tests) gets a throwaway reader.
+function _ownScopeFlag(env) {
+  if (env === process.env || !env) return boolFlag('CTM_HOST_OWN_SCOPE', true);
+  return createEnvFlags({ env, warn: () => {} }).boolFlag('CTM_HOST_OWN_SCOPE', true);
+}
+
+const SCOPE_MOVE_TIMEOUT_MS = 5000; // busctl is a local bus call; the probe measured 6 ms
+const SCOPE_PREFIX = 'ctm-host-'; // unit = `${SCOPE_PREFIX}${sanitize(label)}-${pid}.scope`
+
+/** True iff this process is a systemd service (INVOCATION_ID is set by systemd for a unit's own processes). */
+function isSystemdService({ platform = process.platform, env = process.env } = {}) {
+  return platform === 'linux' && !!(env && env.INVOCATION_ID);
+}
+
+/** True iff the scope move is enabled: a systemd service and CTM_HOST_OWN_SCOPE not explicitly falsy. */
+function scopeMoveEnabled({ platform = process.platform, env = process.env } = {}) {
+  return isSystemdService({ platform, env }) && _ownScopeFlag(env);
+}
+
+function _sanitizeLabel(label) {
+  const cleaned = String(label || 'host').replace(/[^A-Za-z0-9_.:-]/g, '-').replace(/^-+|-+$/g, '').slice(0, 60);
+  return cleaned || 'host';
+}
+
+function _scopeArgv(unit, pid, label) {
+  return ['--user', 'call', 'org.freedesktop.systemd1', '/org/freedesktop/systemd1',
+    'org.freedesktop.systemd1.Manager', 'StartTransientUnit', 'ssa(sv)a(sa(sv))',
+    unit, 'fail', '3', 'PIDs', 'au', '1', String(pid), 'CollectMode', 's', 'inactive-or-failed',
+    'Description', 's', `CTM survivor: ${label}`, '0'];
+}
+
+/**
+ * Move `pid` into a new transient user scope. Never throws.
+ * @returns {Promise<{ moved: boolean, unit: string|null, reason: string|null, ms: number }>}
+ *   reason: 'disabled' | 'not-systemd' | 'bad-pid' | 'timeout' | `exit-${code}: ${stderr}` | 'ENOENT' | `error: ...`
+ */
+async function moveToOwnScope(pid, {
+  label = 'host', platform = process.platform, env = process.env,
+  execFileImpl = execFile, timeoutMs = SCOPE_MOVE_TIMEOUT_MS,
+} = {}) {
+  const started = Date.now();
+  const fail = (reason) => ({ moved: false, unit: null, reason, ms: Date.now() - started });
+  try {
+    if (!isSystemdService({ platform, env })) return fail('not-systemd');
+    if (!_ownScopeFlag(env)) return fail('disabled');
+    const n = Number(pid);
+    if (!Number.isInteger(n) || n <= 1) return fail('bad-pid');
+    const safeLabel = _sanitizeLabel(label);
+    const unit = `${SCOPE_PREFIX}${safeLabel}-${n}.scope`;
+    return await new Promise((resolve) => {
+      let settled = false;
+      const done = (r) => { if (!settled) { settled = true; resolve(r); } };
+      try {
+        execFileImpl('busctl', _scopeArgv(unit, n, safeLabel), { timeout: timeoutMs }, (error, _stdout, stderr) => {
+          if (!error) return done({ moved: true, unit, reason: null, ms: Date.now() - started });
+          if (error.code === 'ENOENT') return done(fail('ENOENT'));
+          if (error.killed || error.signal === 'SIGTERM' || error.code === 'ETIMEDOUT') return done(fail('timeout'));
+          if (Number.isInteger(error.code)) return done(fail(`exit-${error.code}: ${String(stderr || error.message || '').trim().slice(0, 200)}`));
+          return done(fail(`error: ${String(error.message || error).slice(0, 200)}`));
+        });
+      } catch (err) {
+        // HANDLE: a synchronous spawn failure is classified like an async one; the caller reports it.
+        done(fail(err && err.code === 'ENOENT' ? 'ENOENT' : `error: ${String(err && err.message || err).slice(0, 200)}`));
+      }
+    });
+  } catch (err) {
+    // HANDLE: moveToOwnScope never throws; the classified reason is REPORTED by the caller.
+    return fail(`error: ${String(err && err.message || err).slice(0, 200)}`);
+  }
+}
+
+function _cgroupLine(text) {
+  const line = String(text || '').split('\n').find((l) => l.startsWith('0::'));
+  return line ? line.trim() : null;
+}
+
+/**
+ * Synchronous truth for the restart guard (D-5). True when not a systemd service (launchd semantics: proven),
+ * or when /proc/<pid>/cgroup's '0::' line differs from /proc/self/cgroup's. False on any read error.
+ */
+function pidSurvivesServiceStop(pid, { platform = process.platform, env = process.env, readFileSync = fs.readFileSync } = {}) {
+  if (!isSystemdService({ platform, env })) return true;
+  const n = Number(pid);
+  if (!Number.isInteger(n) || n <= 0) return false;
+  try {
+    const mine = _cgroupLine(readFileSync('/proc/self/cgroup', 'utf8'));
+    const theirs = _cgroupLine(readFileSync(`/proc/${n}/cgroup`, 'utf8'));
+    if (!mine || !theirs) return false;
+    return mine !== theirs;
+  } catch {
+    // HANDLE: a dead/unreadable pid cannot survive anything -- the guard treats it as not surviving.
+    return false;
+  }
+}
+
+module.exports = { isSystemdService, scopeMoveEnabled, moveToOwnScope, pidSurvivesServiceStop, SCOPE_MOVE_TIMEOUT_MS, SCOPE_PREFIX };

package/template/coding-task-manager/lib/telemetry-receiver.js

@@ -213,6 +213,29 @@ function markAuthoritative(id, source) {
   authoritative.set(id, source);
 }
 
+// R4 (WP-1): a duration in the owner's own units -- "<h> h <m> m" from an hour up, "<m> m" below it.
+// Floored to whole minutes and never negative, so the line reads the same at 30 m as at 29.9 m.
+function bgNudgeDuration(ms) {
+  const minutes = Math.max(0, Math.floor((Number(ms) || 0) / 60000));
+  return minutes >= 60 ? `${Math.floor(minutes / 60)} h ${minutes % 60} m` : `${minutes} m`;
+}
+
+/*
+ * R4 (WP-1): one line of evidence per quiet declared task, delivered as a Stop notice. Pure: it reads the
+ * entry a ledger reader produced and names the owner's own remedy (TaskStop) -- CTM itself never signals.
+ * The entry's label is already capped at BG_LABEL_MAX; its newlines are folded so the notice stays one line.
+ */
+function renderBackgroundNudge(d, now = Date.now()) {
+  const label = String(d.label || '').replace(/\s*[\r\n]+\s*/g, ' ').trim();
+  const deadlineMs = Number(d.deadlineMs) > 0 ? Number(d.deadlineMs) : 0;
+  const firstSeenAt = Number(d.firstSeenAt) || 0;
+  const written = Number(d.outMtimeMs) > 0 ? `${bgNudgeDuration(now - Number(d.outMtimeMs))} ago` : 'never';
+  const deadlinePart = deadlineMs && firstSeenAt + deadlineMs > now
+    ? `Its own deadline ends it in ${bgNudgeDuration(firstSeenAt + deadlineMs - now)}.`
+    : 'It has no declared deadline.';
+  return `Background task ${d.id} has been quiet for ${bgNudgeDuration(d.quietForMs)} (started ${bgNudgeDuration(now - firstSeenAt)} ago; output ${Number(d.outSize) || 0} bytes, last written ${written}; no CPU activity seen since): ${label}. ${deadlinePart} If it is no longer needed, run TaskStop ${d.id}. If it must keep running, say why in one line.`;
+}
+
 // `ledger` = { kind, meta } is the typed status-ledger evidence for this broadcast (session-status-truth
 // D-3/D-12). It rides the in-process message as a NON-enumerable property so the WS wire shape is unchanged.
 function broadcastStatus(id, working, source, ledger) {
@@ -660,6 +683,21 @@ function hookClaude(route, payload) {
     // After approval menu, Claude can already be idle before Stop hook arrives.
     // Force a terminal.capture so the UI gets a fresh snapshot of post-menu state.
     setTimeout(() => broadcastFn?.({ type: 'terminal.capture', id }), 500);
+    /*
+     * R4 (WP-1): the owner is asked, never killed. Once the Stop's declared set is on the ledger, list the
+     * entries backgroundQuiet already calls quiet and hand one evidence line per task back as a notice --
+     * except while the CLI itself says this Stop is already inside a continuation (stop_hook_active), where
+     * a nudge would feed the platform's own loop. No timer, no signal, no process inspection: it is a read.
+     */
+    const nudgedAt = Date.now();
+    const ledger = sessForTranscript?._statusLedger;
+    if (ledger && hookJson(payload, 'stop_hook_active') !== true) {
+      const due = ledger.backgroundNudges(nudgedAt);
+      if (due.length) {
+        ledger.noteBackgroundNudged(due.map((d) => d.id), nudgedAt);
+        return { matched: true, backgroundNudges: due.map((d) => ({ id: d.id, text: renderBackgroundNudge(d, nudgedAt) })) };
+      }
+    }
     return { matched: true };
   }
   if (route === 'idle' || route === 'waiting') {
@@ -862,6 +900,7 @@ module.exports = {
   getAuthoritativeSource,
   getReceiptStats,
   // exposed for tests
+  renderBackgroundNudge,
   _test: {
     parseAttrs, resolveSessionId, codexPendingStop, codexPendingTools,
     resolveSessionIdFromAgentToken, resolveSessionIdForRecord,