create-walle 0.10.2 → 0.10.3

package/template/coding-task-manager/lib/terminal-bootstrap.js

@@ -7,6 +7,11 @@
 // that produced `ansi` (one authority, one instant), reusing the exact normalizers the frame path
 // (lib/state-sync/frame-emitter.js) already uses so both paths can only ever mint the same shape.
 const { normalizeMouseTracking, normalizeMouseEncoding } = require('./state-sync/surface-mouse');
+// WP-1 (remote-terminal-cursor-and-geometry-claim-relay-2026-10-27 D-1): the keyframe bootstrap
+// body is the frame emitter's own repaint, so it is built from the SAME two modules the frame path
+// uses -- one diff core, one empty-grid constant, no second implementation of either.
+const { computeAnsiPatch } = require('./state-sync/cell-diff');
+const { EMPTY_GRID } = require('./state-sync/frame-emitter');
 
 // Cold terminal bootstrap is deliberately a standalone protocol.  It neither
 // carries activation ownership metadata nor shares the legacy keyframe shape.
@@ -251,6 +256,29 @@ function composeTerminalBootstrapResult(input) {
   return _bounded(result);
 }
 
+// WP-1 (D-1/D-2): a repaint is not complete until the cursor is placed. This is the server-side
+// twin of the client's frame rule (public/js/state-sync-client.js:938-942): CUP to the mirror's
+// 1-based row/col, then DECTCEM ?25h/?25l for visibility. An absent cursor -- or a non-positive,
+// non-integer row/col -- appends nothing, exactly the client's own guard, so a grid with no cursor
+// mints byte-identical bytes and this can never invent a position the mirror did not state.
+function appendBootstrapCursor(bodyAnsi, cursor) {
+  if (!cursor || typeof cursor !== 'object') return bodyAnsi;
+  const row = cursor.row;
+  const col = cursor.col;
+  if (!Number.isInteger(row) || row <= 0 || !Number.isInteger(col) || col <= 0) return bodyAnsi;
+  return bodyAnsi + '\x1b[' + row + ';' + col + 'H' + (cursor.visible === false ? '\x1b[?25l' : '\x1b[?25h');
+}
+
+// The keyframe bootstrap ansi: the full-viewport repaint (CUP+SGR0+EL2 per row, no RIS/ESC[3J) with
+// the cursor tail appended from the SAME grid object the body was computed from -- one extract, one
+// instant (D-1), so the body and the tail can never describe two different frames.
+function keyframeBootstrapAnsi(grid) {
+  return appendBootstrapCursor(
+    computeAnsiPatch(EMPTY_GRID, grid, { keyframe: true }).ansi,
+    grid && grid.cursor,
+  );
+}
+
 module.exports = {
   MAX_TERMINAL_BOOTSTRAP_BYTES,
   parseTerminalBootstrapRequest,
@@ -259,4 +287,6 @@ module.exports = {
   parseTerminalBootstrapFlushComplete,
   composeTerminalBootstrapResult,
   truncateBootstrapAnsi,
+  appendBootstrapCursor,
+  keyframeBootstrapAnsi,
 };

package/template/coding-task-manager/lib/terminal-draft-operation.js

@@ -0,0 +1,357 @@
+'use strict';
+
+// Landing-throughput WP-6 shard S13 (design doc §5 D-10 "move-only", §6 "Shard module
+// seam"): the terminal draft-operation cluster (_runTerminalDraftOperation plus its two private
+// helpers _runLegacyTerminalDraftDbAction and _publishCommittedDraft) moves out of server.js
+// VERBATIM into this module behind the same configure(deps) seam as lib/api/session-attach.js
+// and lib/terminal-attach-geometry.js (S6), lib/walle-history-serve.js (S8),
+// lib/codex-rollout-history.js (S9), lib/terminal-input-prepared.js (S10), lib/idle-notify.js
+// (S11) and lib/session-park.js (S12). It registers NO route and NO socket handler: server.js
+// keeps the pass-through call sites as terminalDraftOperation.<fn>(...), the module-init
+// `setTerminalDraftRunner(terminalDraftOperation._runTerminalDraftOperation)` statement and
+// this configure() seam. Bodies are identical to the server.js declarations except for the
+// `_deps.` prefix on every identifier that used to resolve to a server.js top-level binding
+// (D-10 rule 1), proven by `node bin/move-only-check.js`.
+//
+// The module deliberately lives at lib/terminal-draft-operation.js and NOT under lib/ws/: this is
+// the terminal image-draft store lane, not a ws-router handler.
+//
+// Injected deps, per function:
+//   _runLegacyTerminalDraftDbAction: _legacyDraftCancellationRecovery, _runCtmDbWorkerOp
+//   _publishCommittedDraft: _draftPublicationAuthorityAdmits, _mediaStore, _publishDraftSnapshot, draftReceiptPublication
+//   _runTerminalDraftOperation: MUTATING_DRAFT_OPS, _assertTerminalDraftOwnerAsync, _attachmentTimeline, _imageWriteProofs, _mediaStore, _mediaWriteBehindEnabled, _notePurgedDraftsInMediaStore, _prepareMediaStore, _releaseDraftPublicationOwnership, dbModule, fs, imageDeliveryReconciler, recordSessionDiagnostic, runLegacyDraftRequestCancellation, sanitizeTerminalImageDiagnostic, submittedAttachmentReference
+//
+// Mutable module state (D-10 rule 2 / S9 lesson 7): _mediaStore, _imageWriteProofs and
+// imageDeliveryReconciler are server.js `let`s reassigned during boot/restore (the reconciler is
+// constructed near the bottom of server.js), so each is injected as a GETTER -- never copied. No
+// moved body ASSIGNS a server.js top-level binding, so this seam carries no get/set pair. Every
+// other dep is a by-value reference. Calls between the three moved functions stay direct (no
+// `_deps.`).
+
+let _deps = null;
+
+function configure(deps = {}) {
+  _deps = deps;
+}
+
+async function _runTerminalDraftOperation(op, payload) {
+  // WP-1 (§6.4): while a session is being retired, new deliveries/mutations for its drafts are
+  // fenced. Reads (list/content/internal/diagnostic) stay available so the client can converge.
+  if (_deps.MUTATING_DRAFT_OPS.has(op) && _deps._mediaStore?.isSessionRetiring?.(payload.sessionId)) {
+    throw Object.assign(new Error('Image drafts for this session are being retired'), {
+      code: 'CTM_DRAFT_SESSION_RETIRING', status: 409,
+    });
+  }
+  if (op === 'purge-if-unreferenced') {
+    await _deps._assertTerminalDraftOwnerAsync(payload.sessionId);
+    const reference = await _deps.submittedAttachmentReference(
+      _deps.dbModule.SESSION_IMAGES_DIR, payload.sessionId, payload.attachmentId,
+    );
+    if (reference.referenced) return { purged: false, reason: reference.reason };
+    let result;
+    if (_deps._mediaWriteBehindEnabled) {
+      const store = await _deps._prepareMediaStore();
+      result = await store.purgeDraft(payload);
+    } else {
+      result = await _runLegacyTerminalDraftDbAction('purgeTerminalDraftImage', [
+        payload.sessionId, payload.attachmentId, payload,
+      ]);
+      if (result && result.deleted !== false) _deps._notePurgedDraftsInMediaStore(payload.attachmentId);
+    }
+    // WP-2 (§6.5): a permanent deletion releases publication ownership — the hint counter, the
+    // write evidence and the pending watermark for this attachment are dropped, so a replayed
+    // older callback can neither resurrect it nor decorate a future id (ids are never reused).
+    if (result && result.deleted !== false) {
+      _deps._releaseDraftPublicationOwnership({ sessionId: payload.sessionId, attachmentId: payload.attachmentId });
+    }
+    return {
+      purged: result && result.deleted !== false,
+      reason: result && result.deleted === false ? 'not_found' : 'purged',
+    };
+  }
+  if (_deps._mediaWriteBehindEnabled) {
+    const store = await _deps._prepareMediaStore();
+    if (op === 'create') {
+      const item = await store.createDraft(payload);
+      _deps.recordSessionDiagnostic(payload.sessionId, 'image-draft-created', {
+        attachmentId: item.attachmentId,
+        provider: item.provider,
+        ordinal: item.ordinal,
+        revision: item.revision,
+      });
+      _deps._attachmentTimeline.onCreated({
+        sessionId: payload.sessionId, attachmentId: item.attachmentId, provider: item.provider, ordinal: item.ordinal,
+      });
+      // WP-2 (§9 server.js create nudge): publish the committed create receipt (complete identity +
+      // clientRequestId + lifecycle version) BEFORE the HTTP 201 can be observed, so a client that
+      // retains an early publication can correlate it with the response that identifies it.
+      await _publishCommittedDraft(payload.sessionId, item);
+      if (_deps.imageDeliveryReconciler) _deps.imageDeliveryReconciler.nudge(payload.sessionId);
+      return item;
+    }
+    if (op === 'apply') {
+      const item = await store.applyDraft(payload);
+      await _publishCommittedDraft(payload.sessionId, item);
+      return item;
+    }
+    if (op === 'cancel-request') return store.cancelDraftRequest(payload);
+    if (op === 'purge') {
+      const purged = await store.purgeDraft(payload);
+      // WP-2 (§6.5): a committed permanent deletion releases publication ownership for the id.
+      if (purged && purged.deleted !== false) {
+        _deps._releaseDraftPublicationOwnership({ sessionId: payload.sessionId, attachmentId: payload.attachmentId });
+      }
+      return purged;
+    }
+    if (op === 'list') {
+      const recovered = await store.reconcileStaleDrafts(payload.sessionId);
+      for (const item of recovered) {
+        _deps.recordSessionDiagnostic(payload.sessionId, 'image-orphaned', {
+          attachmentId: item.attachmentId, priorState: 'stranded', reason: item.stateReason,
+        });
+        _deps._attachmentTimeline.onTerminal({
+          sessionId: payload.sessionId, attachmentId: item.attachmentId, outcome: 'orphaned', reason: item.stateReason || 'stranded',
+        });
+        // WP-2 (§9 recovery): a recovery transition is published from its own committed receipt,
+        // like every other state change — never inferred by the client from a later list read.
+        await _publishCommittedDraft(payload.sessionId, item);
+      }
+      return store.listDrafts(payload.sessionId);
+    }
+    if (op === 'internal') return store.getDraftInternal(payload.sessionId, payload.attachmentId);
+    if (op === 'state') {
+      const item = await store.setDraftState(payload);
+      const event = payload.state === 'submitted' ? 'image-submit'
+        : (payload.state === 'orphaned' ? 'image-orphaned' : 'image-client-evidence');
+      _deps.recordSessionDiagnostic(payload.sessionId, event, {
+        attachmentId: payload.attachmentId, state: payload.state, reason: item.stateReason || '',
+      });
+      if (payload.state === 'orphaned') {
+        _deps._attachmentTimeline.onTerminal({
+          sessionId: payload.sessionId, attachmentId: payload.attachmentId, outcome: 'orphaned', reason: item.stateReason || '',
+        });
+      } else if (payload.state === 'submitted') {
+        _deps._attachmentTimeline.onTerminal({
+          sessionId: payload.sessionId, attachmentId: payload.attachmentId, outcome: 'submitted', reason: 'prompt_submitted',
+        });
+      }
+      // WP-2 (§9): a public state mutation (freeze/submit/orphan/ready-retry) publishes the
+      // committed snapshot, so list restore and WS adoption carry the same canonical projection
+      // and real stateVersion the HTTP response carries.
+      await _publishCommittedDraft(payload.sessionId, item);
+      // A retry (failed -> ready) needs its own nudge -- unlike a fresh paste, nothing else
+      // notifies the reconciler this draft became deliverable again.
+      if (payload.state === 'ready' && _deps.imageDeliveryReconciler) _deps.imageDeliveryReconciler.nudge(payload.sessionId);
+      return item;
+    }
+    if (op === 'delivery-complete') {
+      const item = await store.completeDraftDelivery(payload);
+      // The reconciler's own exhausted-retry path (lib/image-delivery-reconciler.js 'fail'
+      // action) completes with outcome:'failed', reason:'ack_timeout' -- NOT the legacy
+      // client-driven outcome:'unconfirmed' this ternary originally covered. Without the
+      // reason check, that genuine ack-timeout was silently mis-bucketed as the generic
+      // 'image-client-evidence', hiding it from anything (tests, UI) that looks for
+      // 'image-ack-timeout' specifically. Other outcome:'failed' reasons (e.g. a PTY write
+      // error starting delivery) still fall through to 'image-client-evidence'.
+      const diagnostic = _deps.sanitizeTerminalImageDiagnostic({
+        event: payload.outcome === 'attached' ? 'image-ack-confirmed'
+          : (payload.outcome === 'unconfirmed' || payload.reason === 'ack_timeout' ? 'image-ack-timeout' : 'image-client-evidence'),
+        attachmentId: payload.attachmentId,
+        details: payload,
+      });
+      _deps.recordSessionDiagnostic(payload.sessionId, diagnostic.event, {
+        attachmentId: diagnostic.attachmentId,
+        ...diagnostic.details,
+      });
+      // WP-7: exactly one image-timeline row per attachment, at the FIRST terminal outcome
+      // it reaches (onTerminal is idempotent-per-attachmentId — see lib/image-attachment-timeline.js).
+      _deps._attachmentTimeline.onTerminal({
+        sessionId: payload.sessionId, attachmentId: payload.attachmentId, outcome: payload.outcome,
+        reason: payload.reason || '', ackSource: payload.ackSource || '',
+      });
+      // WP-2 (§9 attached/unconfirmed/failed): the completion receipt is the canonical snapshot for
+      // this transition. A rejected completion throws before this point, so a failure can never be
+      // published as a success.
+      await _publishCommittedDraft(payload.sessionId, item);
+      // Unconfirmed retains its attempt and can still receive a late real-write ACK.
+      if (_deps._imageWriteProofs && item.state !== 'unconfirmed') _deps._imageWriteProofs.release(payload.sessionId, payload.attachmentId);
+      return item;
+    }
+    if (op === 'delivery-begin') return store.beginDraftDelivery(payload);
+    if (op === 'content') return store.getDraftContent(payload.sessionId, payload.attachmentId);
+  }
+  if (op === 'cancel-request') return _deps.runLegacyDraftRequestCancellation(payload.sessionId, payload.requestId, {
+    assertOwnerAsync: _deps._assertTerminalDraftOwnerAsync, runLegacyDbAction: _runLegacyTerminalDraftDbAction,
+  });
+  if (op !== 'diagnostic') await _deps._assertTerminalDraftOwnerAsync(payload.sessionId);
+  if (op === 'create') {
+    const item = await _runLegacyTerminalDraftDbAction('createTerminalDraftImage', [payload]);
+    _deps.recordSessionDiagnostic(payload.sessionId, 'image-draft-created', {
+      attachmentId: item.attachmentId,
+      provider: item.provider,
+      ordinal: item.ordinal,
+      revision: item.revision,
+    });
+    // WP-2 (§9, both lanes): the legacy per-operation lane publishes its committed receipts through
+    // the SAME publication owner as the media-store lane — same canonical projection, same
+    // stateVersion, same correlation identity.
+    await _publishCommittedDraft(payload.sessionId, item);
+    _deps._attachmentTimeline.onCreated({
+      sessionId: payload.sessionId, attachmentId: item.attachmentId, provider: item.provider, ordinal: item.ordinal,
+    });
+    if (_deps.imageDeliveryReconciler) _deps.imageDeliveryReconciler.nudge(payload.sessionId);
+    return item;
+  }
+  if (op === 'apply') {
+    const item = await _runLegacyTerminalDraftDbAction('applyTerminalDraftImage', [payload]);
+    await _publishCommittedDraft(payload.sessionId, item);
+    return item;
+  }
+  if (op === 'purge') {
+    const purged = await _runLegacyTerminalDraftDbAction('purgeTerminalDraftImage', [
+      payload.sessionId, payload.attachmentId, payload,
+    ]);
+    if (purged && purged.deleted !== false) _deps._notePurgedDraftsInMediaStore(payload.attachmentId);
+    if (purged && purged.deleted !== false) {
+      _deps._releaseDraftPublicationOwnership({ sessionId: payload.sessionId, attachmentId: payload.attachmentId });
+    }
+    return purged;
+  }
+  if (op === 'list') {
+    const recovered = await _runLegacyTerminalDraftDbAction(
+      'reconcileStaleTerminalDraftImages', [{ sessionId: payload.sessionId }],
+    );
+    for (const item of recovered) {
+      _deps.recordSessionDiagnostic(payload.sessionId, 'image-orphaned', {
+        attachmentId: item.attachmentId, priorState: 'stranded', reason: item.stateReason,
+      });
+      _deps._attachmentTimeline.onTerminal({
+        sessionId: payload.sessionId, attachmentId: item.attachmentId, outcome: 'orphaned', reason: item.stateReason || 'stranded',
+      });
+      // WP-2 (§9 recovery, both lanes): a recovery transition publishes its own committed receipt.
+      await _publishCommittedDraft(payload.sessionId, item);
+    }
+    return _runLegacyTerminalDraftDbAction('listTerminalDraftImages', [payload.sessionId]);
+  }
+  if (op === 'state') {
+    const item = await _runLegacyTerminalDraftDbAction('setTerminalDraftImageState', [
+      payload.sessionId, payload.attachmentId, payload.state, payload,
+    ]);
+    const event = payload.state === 'submitted' ? 'image-submit'
+      : (payload.state === 'orphaned' ? 'image-orphaned' : 'image-client-evidence');
+    _deps.recordSessionDiagnostic(payload.sessionId, event, {
+      attachmentId: payload.attachmentId, state: payload.state, reason: item.stateReason || '',
+    });
+    if (payload.state === 'orphaned') {
+      _deps._attachmentTimeline.onTerminal({
+        sessionId: payload.sessionId, attachmentId: payload.attachmentId, outcome: 'orphaned', reason: item.stateReason || '',
+      });
+    } else if (payload.state === 'submitted') {
+      _deps._attachmentTimeline.onTerminal({
+        sessionId: payload.sessionId, attachmentId: payload.attachmentId, outcome: 'submitted', reason: 'prompt_submitted',
+      });
+    }
+    // WP-2 (§9): a public state mutation (freeze/submit/orphan/ready-retry) publishes the committed
+    // snapshot in this lane too.
+    await _publishCommittedDraft(payload.sessionId, item);
+    if (payload.state === 'ready' && _deps.imageDeliveryReconciler) _deps.imageDeliveryReconciler.nudge(payload.sessionId);
+    return item;
+  }
+  if (op === 'delivery-complete') {
+    const item = await _runLegacyTerminalDraftDbAction('completeTerminalDraftImageDelivery', [
+      payload.sessionId, payload.attachmentId, payload.attemptId, payload.outcome, payload,
+    ]);
+    // See the matching comment in the media-write-behind branch above: the reconciler's own
+    // exhausted-retry path completes with outcome:'failed', reason:'ack_timeout', which also
+    // needs to surface as 'image-ack-timeout' here, not just the legacy 'unconfirmed' outcome.
+    const diagnostic = _deps.sanitizeTerminalImageDiagnostic({
+      event: payload.outcome === 'attached' ? 'image-ack-confirmed' :
+        (payload.outcome === 'unconfirmed' || payload.reason === 'ack_timeout' ? 'image-ack-timeout' : 'image-client-evidence'),
+      attachmentId: payload.attachmentId,
+      details: {
+        attachmentId: payload.attachmentId,
+        attemptId: payload.attemptId,
+        outcome: payload.outcome,
+        providerOrdinal: payload.providerOrdinal || 0,
+        source: payload.ackSource || '',
+        elapsedMs: Number(payload.elapsedMs || 0),
+        reason: payload.reason || '',
+      },
+    });
+    _deps.recordSessionDiagnostic(payload.sessionId, diagnostic.event, {
+      attachmentId: diagnostic.attachmentId,
+      ...diagnostic.details,
+    });
+    _deps._attachmentTimeline.onTerminal({
+      sessionId: payload.sessionId, attachmentId: payload.attachmentId, outcome: payload.outcome,
+      reason: payload.reason || '', ackSource: payload.ackSource || '',
+    });
+    await _publishCommittedDraft(payload.sessionId, item);
+    // Unconfirmed retains its attempt and can still receive a late real-write ACK.
+    if (_deps._imageWriteProofs && item.state !== 'unconfirmed') _deps._imageWriteProofs.release(payload.sessionId, payload.attachmentId);
+    return item;
+  }
+  if (op === 'delivery-begin') {
+    return _runLegacyTerminalDraftDbAction('beginTerminalDraftImageDelivery', [
+      payload.sessionId, payload.attachmentId, payload.attemptId, payload,
+    ]);
+  }
+  if (op === 'diagnostic') {
+    const clean = _deps.sanitizeTerminalImageDiagnostic(payload);
+    _deps.recordSessionDiagnostic(payload.sessionId, clean.event, {
+      attachmentId: clean.attachmentId,
+      ...clean.details,
+      clientMetrics: clean.metrics,
+    });
+    return { accepted: true };
+  }
+  if (op === 'content') {
+    const item = await _runLegacyTerminalDraftDbAction('getTerminalDraftImageInternal', [
+      payload.sessionId, payload.attachmentId,
+    ]);
+    if (!item) return null;
+    return { buffer: await _deps.fs.promises.readFile(item.workingPath), mimeType: item.mimeType, etag: item.etag };
+  }
+  if (op === 'internal') {
+    return _runLegacyTerminalDraftDbAction('getTerminalDraftImageInternal', [
+      payload.sessionId, payload.attachmentId,
+    ]);
+  }
+  throw new Error(`Unknown terminal draft operation: ${String(op || '')}`);
+}
+
+async function _runLegacyTerminalDraftDbAction(action, args) {
+  await _deps._legacyDraftCancellationRecovery.prepare();
+  return _deps._runCtmDbWorkerOp('runDbMutation', { action, args }, {
+    priority: 'urgent',
+    requestClass: 'user-blocking',
+    timeoutMs: 10_000,
+  });
+}
+
+// WP-2 (§6/§6.3, D8): publish one COMMITTED draft mutation receipt — the exact projection the store
+// just returned from its own commit, never a locally re-assembled patch. A receipt that is missing
+// identity/lifecycle version is classified and dropped by the publication owner instead of being
+// guessed at, and a failed/rejected mutation never reaches this function (it throws instead).
+// Called before the mutation's HTTP/WS reply so a client can correlate the publication with the
+// response it is about to receive (D1's correlation ID travels on every publication).
+async function _publishCommittedDraft(sessionId, receipt) {
+  // The "is this a publishable committed receipt" decision is shared with the legacy lane
+  // (draftReceiptPublication), so both lanes cannot drift apart.
+  const publication = _deps.draftReceiptPublication(receipt);
+  if (!publication) return { published: false, reason: 'no-receipt' };
+  if (!_deps._mediaStore) {
+    const admitted = await _deps._draftPublicationAuthorityAdmits({
+      sessionId, attachmentId: publication.attachmentId, snapshot: receipt,
+    });
+    if (!admitted) return { published: false, reason: 'not-admitted' };
+  }
+  return _deps._publishDraftSnapshot(sessionId, publication.attachmentId, publication.kind, receipt, publication.hint);
+}
+
+module.exports = {
+  configure,
+  _runTerminalDraftOperation,
+  _runLegacyTerminalDraftDbAction,
+  _publishCommittedDraft,
+};

package/template/coding-task-manager/lib/terminal-input-admission.js

@@ -8,6 +8,22 @@ function decideRawTerminalInput(facts = {}) {
   return { allowed: true, reason: null };
 }
 
+// WP-1 (live-defer-wake-adopted-host-death-2026-10-28.html §5 R-1/R-2): a raw keystroke to a
+// session whose process died under an open tab must take the deferred wake, not the raw-input
+// pty_unavailable refusal. Pure predicate so the server's rejected-admission branch and the
+// existing deferred-wake branch share ONE rule. It is deliberately narrow: only a genuine
+// pty_unavailable rejection on a WRITABLE socket wakes. decideRawTerminalInput reports
+// pty-unavailable ahead of read-only (its ptyAlive check precedes readOnly), so a read-only
+// viewer's keystroke on a deferred session would otherwise be indistinguishable from the owner's
+// -- and a read-only viewer must never respawn a session. Parking keeps its own hold + refusal.
+function shouldWakeDeferredOnRawInput({ rawTerminalInput, rejectionReason, readOnly, restoreDeferred, parking }) {
+  return rawTerminalInput === true
+    && rejectionReason === 'pty_unavailable'
+    && readOnly !== true
+    && restoreDeferred === true
+    && parking !== true;
+}
+
 function terminalInputAdmissionFacts(session, msg, getProcessGeneration) {
   const expectedResumeGeneration = Number(session?._launchPlanGeneration || 0);
   const expectedProcessGeneration = typeof getProcessGeneration === 'function'
@@ -22,4 +38,4 @@ function terminalInputAdmissionFacts(session, msg, getProcessGeneration) {
   };
 }
 
-module.exports = { decideRawTerminalInput, terminalInputAdmissionFacts };
+module.exports = { decideRawTerminalInput, terminalInputAdmissionFacts, shouldWakeDeferredOnRawInput };