create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/lib/remote-feedback-client.js

@@ -6,12 +6,22 @@ const DEFAULT_FEEDBACK_URL = process.env.CTM_FEEDBACK_URL
   || process.env.WALLE_FEEDBACK_URL
   || 'https://create-walle.fly.dev/api/wall-e/feedback/submit';
 
+const DEFAULT_TELEMETRY_URL = process.env.CTM_TELEMETRY_URL
+  || process.env.WALLE_TELEMETRY_URL
+  || 'https://create-walle.fly.dev/api/wall-e/telemetry/ingest';
+
 function endpoint() {
   return process.env.CTM_FEEDBACK_URL
     || process.env.WALLE_FEEDBACK_URL
     || DEFAULT_FEEDBACK_URL;
 }
 
+function telemetryEndpoint() {
+  return process.env.CTM_TELEMETRY_URL
+    || process.env.WALLE_TELEMETRY_URL
+    || DEFAULT_TELEMETRY_URL;
+}
+
 function buildEnvelope(feedback) {
   const envelope = {
     id: telemetry.getInstallId(),
@@ -26,11 +36,34 @@ function buildEnvelope(feedback) {
   return envelope;
 }
 
+function buildTelemetryEnvelope(event, meta = {}) {
+  const envelope = {
+    id: telemetry.getInstallId(),
+    machine: telemetry.getMachineBucket(),
+    v: telemetry.getVersion(),
+    os: process.platform,
+    node: process.version,
+    events: [{
+      e: String(event || 'ctm_event'),
+      m: meta || {},
+      t: Date.now(),
+    }],
+  };
+  const user = telemetry.getTelemetryUser();
+  if (user) envelope.user = user;
+  return envelope;
+}
+
 function isFeedbackDisabled() {
   const value = String(process.env.CTM_FEEDBACK || '').toLowerCase();
   return value === '0' || value === 'false';
 }
 
+function isTelemetryDisabled() {
+  const value = String(process.env.CTM_TELEMETRY || '').toLowerCase();
+  return value === '0' || value === 'false';
+}
+
 async function submitFeedback(feedback, options = {}) {
   if (isFeedbackDisabled()) {
     return { ok: false, skipped: true, reason: 'feedback_disabled' };
@@ -66,9 +99,48 @@ async function submitFeedback(feedback, options = {}) {
   }
 }
 
+async function submitTelemetryEvent(event, meta = {}, options = {}) {
+  if (isTelemetryDisabled()) {
+    return { ok: false, skipped: true, reason: 'telemetry_disabled' };
+  }
+  const fetchImpl = options.fetchImpl || global.fetch;
+  if (typeof fetchImpl !== 'function') {
+    return { ok: false, skipped: true, reason: 'fetch_unavailable' };
+  }
+  const url = options.url || telemetryEndpoint();
+  const body = buildTelemetryEnvelope(event, meta);
+  const controller = typeof AbortController === 'function' ? new AbortController() : null;
+  let timer = null;
+  if (controller) {
+    timer = setTimeout(() => controller.abort(), Number(options.timeoutMs || 10000));
+    if (typeof timer.unref === 'function') timer.unref();
+  }
+  try {
+    const res = await fetchImpl(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: controller?.signal,
+    });
+    const json = await res.json().catch(() => ({}));
+    if (!res.ok || json.ok === false) {
+      return { ok: false, status: res.status, error: json.error || `HTTP ${res.status}` };
+    }
+    return { ok: true, status: res.status, ...json };
+  } catch (err) {
+    return { ok: false, error: err.name === 'AbortError' ? 'timeout' : err.message };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
 module.exports = {
   buildEnvelope,
+  buildTelemetryEnvelope,
   endpoint,
+  telemetryEndpoint,
   isFeedbackDisabled,
+  isTelemetryDisabled,
   submitFeedback,
+  submitTelemetryEvent,
 };

package/template/claude-task-manager/lib/remote-relay-protocol.js

@@ -4,6 +4,25 @@ const relayStore = require('./remote-relay-store');
 
 const REPLAY_WINDOW_MS = 5 * 60 * 1000;
 
+// AUTHORIZATION LAYERING (not a duplicate of lib/auth-rules.js).
+//
+// This is the LOCAL envelope relay (`POST /api/remote/messages`) that the phone
+// uses for typed, idempotent message delivery with the durable submission ledger
+// (ctm_remote_submissions). It is active and current — distinct from the
+// deprecated *hosted* "Walle Relay" product in walle-relay-phone-access-design.md.
+//
+// Authorization is intentionally two-layered, at two different granularities:
+//   1. lib/auth-rules.js gates the `/api/remote/messages` HTTP ROUTE
+//      (scope=respond) — the transport-level gate every request passes.
+//   2. MESSAGE_REGISTRY below gates each ENVELOPE MESSAGE TYPE (scope, risk,
+//      step-up, enabled) — finer-grained policy for the action the envelope
+//      carries (e.g. approval.respond requires step-up; high-risk admin types
+//      are disabled). The route gate cannot express per-message-type policy, so
+//      this layer is additive defense-in-depth, not a second copy of the same
+//      rules.
+// Keep both in sync conceptually: a message type that mutates session/agent
+// state must require step-up here just as its WS/HTTP equivalent does in
+// auth-rules.js.
 const MESSAGE_REGISTRY = Object.freeze({
   'instance.status': rule('read', 'low', false),
   'sessions.list': rule('read', 'low', false),
@@ -12,16 +31,18 @@ const MESSAGE_REGISTRY = Object.freeze({
   'wall_e.status': rule('read', 'low', false),
 
   'session.send_message': rule('respond', 'low', false),
+  'session.submit_input': rule('respond', 'medium', false),
   'session.cancel_stream': rule('respond', 'medium', false),
   'session.prompt_history': rule('respond', 'medium', false),
+  'session.select_choice': rule('respond', 'medium', false),
   'wall_e.send_message': rule('respond', 'low', false),
   'wall_e.set_model': rule('respond', 'low', false),
 
-  'approval.respond': rule('respond', 'high', true, { enabled: false }),
+  'approval.respond': rule('respond', 'high', true),
   'session.kill': rule('admin', 'high', true, { enabled: false }),
   'session.close': rule('admin', 'high', true, { enabled: false }),
   'network.setup_change': rule('admin', 'high', true, { enabled: false }),
-  'ctm.restart': rule('admin', 'high', true, { enabled: false }),
+  'ctm.restart': rule('admin', 'high', false, { enabled: false }),
 });
 
 function rule(scope, risk, stepUp, extra = {}) {
@@ -123,7 +144,11 @@ async function dispatchMessage(message, context = {}) {
       return handlers.wallEStatus ? handlers.wallEStatus(message.body) : { ok: true, status: 'unknown' };
     case 'session.send_message':
       return handlers.sendSessionMessage
-        ? handlers.sendSessionMessage(sessionIdFromBody(message.body), String(message.body.text || message.body.message || ''))
+        ? handlers.sendSessionMessage(sessionIdFromBody(message.body), String(message.body.text || message.body.message || ''), message.body, message)
+        : safeError('handler_missing');
+    case 'session.submit_input':
+      return handlers.submitSessionInput
+        ? handlers.submitSessionInput(sessionIdFromBody(message.body), message.body, message)
         : safeError('handler_missing');
     case 'session.cancel_stream':
       return handlers.cancelSessionStream
@@ -136,14 +161,22 @@ async function dispatchMessage(message, context = {}) {
         ? handlers.navigatePromptHistory(sessionIdFromBody(message.body), direction, message.body)
         : safeError('handler_missing');
     }
+    case 'session.select_choice':
+      return handlers.selectChoice
+        ? handlers.selectChoice(sessionIdFromBody(message.body), message.body, message)
+        : safeError('handler_missing');
     case 'wall_e.send_message':
       return handlers.sendWalleMessage
-        ? handlers.sendWalleMessage(sessionIdFromBody(message.body), String(message.body.text || message.body.message || ''), message.body)
+        ? handlers.sendWalleMessage(sessionIdFromBody(message.body), String(message.body.text || message.body.message || ''), message.body, message)
         : safeError('handler_missing');
     case 'wall_e.set_model':
       return handlers.setWalleModel
         ? handlers.setWalleModel(sessionIdFromBody(message.body), message.body)
         : safeError('handler_missing');
+    case 'approval.respond':
+      return handlers.respondApproval
+        ? handlers.respondApproval(sessionIdFromBody(message.body), String(message.body.decision || message.body.action || ''), message.body, message)
+        : safeError('handler_missing');
     default:
       return safeError('remote_action_not_enabled');
   }

package/template/claude-task-manager/lib/remote-relay-store.js

@@ -69,8 +69,27 @@ function ensureRemoteRelaySchema(db) {
       created_at INTEGER NOT NULL
     );
 
+    CREATE TABLE IF NOT EXISTS ctm_remote_submissions (
+      message_id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      device_id TEXT,
+      message_type TEXT NOT NULL,
+      text_hash TEXT NOT NULL,
+      text_preview TEXT,
+      status TEXT NOT NULL,
+      result_json TEXT,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      accepted_at INTEGER,
+      expires_at INTEGER,
+      last_error TEXT
+    );
+
     CREATE INDEX IF NOT EXISTS idx_ctm_remote_audit_created ON ctm_remote_audit_log(created_at DESC);
     CREATE INDEX IF NOT EXISTS idx_ctm_remote_audit_device ON ctm_remote_audit_log(device_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_ctm_remote_submissions_session ON ctm_remote_submissions(session_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_ctm_remote_submissions_status ON ctm_remote_submissions(status, updated_at DESC);
   `);
 }
 
@@ -218,6 +237,140 @@ function listAudit(db, options = {}) {
   }));
 }
 
+function submissionTextHash(text) {
+  return crypto.createHash('sha256').update(String(text || '')).digest('hex').slice(0, 32);
+}
+
+function submissionTextPreview(text, limit = 240) {
+  return String(text || '').replace(/\s+/g, ' ').trim().slice(0, Math.max(16, Number(limit) || 240));
+}
+
+function submissionFromRow(row) {
+  if (!row) return null;
+  return {
+    message_id: row.message_id,
+    session_id: row.session_id,
+    device_id: row.device_id || '',
+    message_type: row.message_type,
+    text_hash: row.text_hash,
+    text_preview: row.text_preview || '',
+    status: row.status,
+    result: safeJsonParse(row.result_json, null),
+    attempts: Number(row.attempts || 0) || 0,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    accepted_at: row.accepted_at || null,
+    expires_at: row.expires_at || null,
+    last_error: row.last_error || '',
+  };
+}
+
+function upsertRemoteSubmission(db, entry = {}, atMs = nowMs()) {
+  ensureRemoteRelaySchema(db);
+  const messageId = String(entry.messageId || entry.message_id || '').trim();
+  const sessionId = String(entry.sessionId || entry.session_id || '').trim();
+  const messageType = String(entry.messageType || entry.message_type || '').trim();
+  if (!messageId || !sessionId || !messageType) return null;
+  const text = String(entry.text || '');
+  const textHash = String(entry.textHash || entry.text_hash || submissionTextHash(text));
+  const textPreview = String(entry.textPreview || entry.text_preview || submissionTextPreview(text));
+  const status = String(entry.status || 'received');
+  const resultJson = JSON.stringify(entry.result || {});
+  const attempts = Math.max(0, Number(entry.attempts || 0) || 0);
+  const expiresAt = entry.expiresAt || entry.expires_at || null;
+  db.prepare(`
+    INSERT INTO ctm_remote_submissions
+      (message_id, session_id, device_id, message_type, text_hash, text_preview, status, result_json, attempts, created_at, updated_at, accepted_at, expires_at, last_error)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(message_id) DO UPDATE SET
+      session_id = excluded.session_id,
+      device_id = excluded.device_id,
+      message_type = excluded.message_type,
+      text_hash = excluded.text_hash,
+      text_preview = excluded.text_preview,
+      status = excluded.status,
+      result_json = excluded.result_json,
+      attempts = excluded.attempts,
+      updated_at = excluded.updated_at,
+      accepted_at = COALESCE(excluded.accepted_at, ctm_remote_submissions.accepted_at),
+      expires_at = excluded.expires_at,
+      last_error = excluded.last_error
+  `).run(
+    messageId,
+    sessionId,
+    String(entry.deviceId || entry.device_id || ''),
+    messageType,
+    textHash,
+    textPreview,
+    status,
+    resultJson,
+    attempts,
+    entry.createdAt || entry.created_at || atMs,
+    atMs,
+    entry.acceptedAt || entry.accepted_at || null,
+    expiresAt,
+    String(entry.lastError || entry.last_error || ''),
+  );
+  return getRemoteSubmission(db, messageId);
+}
+
+function updateRemoteSubmission(db, messageId, patch = {}, atMs = nowMs()) {
+  ensureRemoteRelaySchema(db);
+  const id = String(messageId || '').trim();
+  if (!id) return null;
+  const existing = getRemoteSubmission(db, id);
+  if (!existing) return null;
+  const next = {
+    status: String(patch.status || existing.status),
+    result: patch.result == null ? (existing.result || {}) : patch.result,
+    attempts: patch.attempts == null ? existing.attempts : Math.max(0, Number(patch.attempts || 0) || 0),
+    accepted_at: patch.acceptedAt || patch.accepted_at || existing.accepted_at || null,
+    expires_at: patch.expiresAt || patch.expires_at || existing.expires_at || null,
+    last_error: patch.lastError || patch.last_error || existing.last_error || '',
+  };
+  db.prepare(`
+    UPDATE ctm_remote_submissions
+    SET status = ?, result_json = ?, attempts = ?, updated_at = ?, accepted_at = ?, expires_at = ?, last_error = ?
+    WHERE message_id = ?
+  `).run(
+    next.status,
+    JSON.stringify(next.result || {}),
+    next.attempts,
+    atMs,
+    next.accepted_at,
+    next.expires_at,
+    next.last_error,
+    id,
+  );
+  return getRemoteSubmission(db, id);
+}
+
+function getRemoteSubmission(db, messageId) {
+  ensureRemoteRelaySchema(db);
+  return submissionFromRow(db.prepare('SELECT * FROM ctm_remote_submissions WHERE message_id = ?').get(String(messageId || '')));
+}
+
+function listRemoteSubmissions(db, options = {}) {
+  ensureRemoteRelaySchema(db);
+  const limit = Math.max(1, Math.min(200, Number(options.limit || 50)));
+  const sessionId = String(options.sessionId || options.session_id || '').trim();
+  const sinceMs = Math.max(0, Number(options.sinceMs || options.since_ms || 0) || 0);
+  const rows = sessionId
+    ? db.prepare(`
+        SELECT * FROM ctm_remote_submissions
+        WHERE session_id = ? AND updated_at >= ?
+        ORDER BY updated_at DESC
+        LIMIT ?
+      `).all(sessionId, sinceMs, limit)
+    : db.prepare(`
+        SELECT * FROM ctm_remote_submissions
+        WHERE updated_at >= ?
+        ORDER BY updated_at DESC
+        LIMIT ?
+      `).all(sinceMs, limit);
+  return rows.map(submissionFromRow).filter(Boolean);
+}
+
 function buildRemoteStatus(db, options = {}) {
   const instance = getOrCreateInstance(db, options.instance || {});
   const relayUrl = normalizeUrl(options.relayUrl || instance.relay_url, DEFAULT_RELAY_URL);
@@ -259,10 +412,16 @@ module.exports = {
   ensureRemoteRelaySchema,
   getIdempotentResult,
   getOrCreateInstance,
+  getRemoteSubmission,
   insertAudit,
   listAudit,
+  listRemoteSubmissions,
   markConnected,
   randomId,
   storeIdempotentResult,
+  submissionTextHash,
+  submissionTextPreview,
   updateInstance,
+  updateRemoteSubmission,
+  upsertRemoteSubmission,
 };

package/template/claude-task-manager/lib/remote-submission-observer.js

@@ -0,0 +1,278 @@
+'use strict';
+
+function stripAnsi(value) {
+  return String(value || '')
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b[@-Z\\-_]/g, '');
+}
+
+function normalizeSubmissionText(text) {
+  return String(text || '').replace(/\r\n?/g, '\n').replace(/\s+/g, ' ').trim();
+}
+
+const TERMINAL_BRACKETED_PASTE_START = '\x1b[200~';
+const TERMINAL_BRACKETED_PASTE_END = '\x1b[201~';
+
+function bracketedPastePayload(text) {
+  return `${TERMINAL_BRACKETED_PASTE_START}${String(text || '').replace(/\x1b/g, '')}${TERMINAL_BRACKETED_PASTE_END}`;
+}
+
+// Decide the exact bytes CTM writes into the PTY for a phone reply. Terminal
+// line editors (Claude/Codex/Gemini/opencode) enable bracketed-paste mode; a
+// real terminal wraps pasted multi-line text in ESC[200~ … ESC[201~ so embedded
+// newlines stay literal text instead of being interpreted as submit/newline
+// keypresses that fragment the message and leave it stuck in the composer.
+// Single-line replies and plain shells are written verbatim (the proven path).
+function remoteSubmissionWritePayload(text, options = {}) {
+  const normalized = String(text || '');
+  if (!normalized) return '';
+  if (normalized.includes('\n') && options.bracketedPasteCapable) {
+    return bracketedPastePayload(normalized);
+  }
+  return normalized;
+}
+
+function submissionTextMatches(candidate, submitted) {
+  const left = normalizeSubmissionText(candidate);
+  const right = normalizeSubmissionText(submitted);
+  if (!left || !right) return false;
+  if (left === right) return true;
+  if (right.length >= 80 && left.includes(right)) return true;
+  if (left.length >= 80 && right.includes(left)) return true;
+  return false;
+}
+
+function promptMessageText(message) {
+  if (message == null) return '';
+  if (typeof message === 'string') return message;
+  return message.text || message.content || message.message || '';
+}
+
+function timestampMs(value) {
+  if (value == null || value === '') return 0;
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value > 0 && value < 100000000000 ? value * 1000 : value;
+  }
+  const text = String(value || '').trim();
+  if (!text) return 0;
+  if (/^\d+(?:\.\d+)?$/.test(text)) {
+    const n = Number(text);
+    return n > 0 && n < 100000000000 ? n * 1000 : n;
+  }
+  const parsed = Date.parse(text);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function promptMessageTimestampMs(message) {
+  if (!message || typeof message !== 'object') return 0;
+  return timestampMs(message.timestamp || message.created_at || message.createdAt || message.time || message.ts);
+}
+
+function durablePromptMatch(messages, submitted, options = {}) {
+  const minTimestampMs = Math.max(0, Number(options.minTimestampMs || options.min_timestamp_ms || 0) || 0);
+  const toleranceMs = Math.max(0, Number(options.timestampToleranceMs ?? options.timestamp_tolerance_ms ?? 0) || 0);
+  const requireFreshTimestamp = minTimestampMs > 0 && options.requireFreshTimestamp !== false;
+  for (const message of (Array.isArray(messages) ? messages : [])) {
+    const text = promptMessageText(message);
+    if (!submissionTextMatches(text, submitted)) continue;
+    const messageTimestampMs = promptMessageTimestampMs(message);
+    if (requireFreshTimestamp) {
+      if (!messageTimestampMs) continue;
+      if (messageTimestampMs + toleranceMs < minTimestampMs) continue;
+    }
+    return {
+      matched: true,
+      text,
+      timestampMs: messageTimestampMs,
+    };
+  }
+  return {
+    matched: false,
+    text: '',
+    timestampMs: 0,
+  };
+}
+
+function promptSuffixMatchesSubmission(candidate, submitted) {
+  const left = normalizeSubmissionText(candidate);
+  const right = normalizeSubmissionText(submitted);
+  if (!left || !right) return false;
+  if (left === right) return true;
+  if (left.endsWith(right)) return true;
+  return submissionTextMatches(left, right);
+}
+
+function normalizeTerminalRows(rows) {
+  return (Array.isArray(rows) ? rows : [])
+    .map((row) => {
+      const source = typeof row === 'string' ? { text: row } : (row || {});
+      return {
+        text: stripAnsi(String(source.text || source.line || '')).replace(/\u00a0/g, ' ').replace(/\s+$/g, ''),
+        wrapped: !!(source.wrapped || source.isWrapped),
+      };
+    })
+    .filter((row) => row.text.trim());
+}
+
+function terminalRowsText(rows) {
+  return normalizeTerminalRows(rows).map((row) => row.text).join('\n');
+}
+
+function stripPromptPrefix(text) {
+  return String(text || '')
+    .replace(/^\s*[›>]\s*/, '')
+    .replace(/^\s*[$#]\s+/, '')
+    .replace(/^[^\s]{1,80}\s+[$#]\s+/, '');
+}
+
+function terminalRowsPromptText(rows) {
+  return normalizeTerminalRows(rows).map((row) => stripPromptPrefix(row.text)).join('\n');
+}
+
+function isPromptStartLine(text) {
+  const t = String(text || '').trim();
+  if (!t) return false;
+  if (/^[›>]\s*/.test(t)) return true;
+  if (/^[$#]\s+\S/.test(t)) return true;
+  return /^[^\s]{1,80}\s+[$#]\s+\S/.test(t);
+}
+
+function isAgentProgressLine(text) {
+  const t = String(text || '').trim();
+  if (!t) return false;
+  return /^(?:Working|Thinking|Explored|Ran|Read|Update|Edit|Write|Bash|Called|Context compacted|Result:|Commit:|Error:|Failed:|✓|✔|✗|✘|[-*]\s+\w)/i.test(t) ||
+    /\b(?:esc to interrupt|tokens?|tool block|tool call|ctrl\+o to expand|almost done thinking)\b/i.test(t);
+}
+
+function isTerminalStatusLine(text) {
+  const t = String(text || '').trim();
+  if (!t) return false;
+  if (/^(?:gpt|claude|gemini|deepseek|kimi|qwen|llama|mistral|codex)[\w.-]*\s+.*(?:·|•)\s*(?:[~./]|\/)/i.test(t)) return true;
+  return false;
+}
+
+function activePromptRowsFromSuffix(suffixRows, submittedText = '') {
+  const promptRows = [];
+  const submitted = normalizeSubmissionText(submittedText);
+  for (let idx = 0; idx < suffixRows.length; idx += 1) {
+    const row = suffixRows[idx];
+    if (idx === 0 || row.wrapped) {
+      promptRows.push(row);
+      continue;
+    }
+    const text = row.text.trim();
+    if (isPromptStartLine(text) || isAgentProgressLine(text) || isTerminalStatusLine(text)) break;
+    if (submitted) {
+      const current = normalizeSubmissionText(promptRows.map((r) => stripPromptPrefix(r.text)).join('\n'));
+      const candidate = normalizeSubmissionText([...promptRows, row].map((r) => stripPromptPrefix(r.text)).join('\n'));
+      if (candidate && candidate.length > current.length && submitted.startsWith(candidate)) {
+        promptRows.push(row);
+        continue;
+      }
+    }
+    break;
+  }
+  return promptRows;
+}
+
+function terminalSubmittedPromptState(rows, submittedText) {
+  const cleanRows = normalizeTerminalRows(rows);
+  let submittedVisible =
+    submissionTextMatches(cleanRows.map((row) => row.text).join('\n'), submittedText) ||
+    submissionTextMatches(cleanRows.map((row) => stripPromptPrefix(row.text)).join('\n'), submittedText);
+  let lastPromptIndex = -1;
+  for (let idx = 0; idx < cleanRows.length; idx += 1) {
+    if (isPromptStartLine(cleanRows[idx].text)) lastPromptIndex = idx;
+  }
+  if (lastPromptIndex < 0) {
+    return {
+      submittedVisible,
+      activePromptVisible: false,
+      agentProgressAfterPrompt: false,
+      lastPromptIndex,
+      rowCount: cleanRows.length,
+    };
+  }
+
+  const suffixRows = cleanRows.slice(lastPromptIndex);
+  const promptRows = activePromptRowsFromSuffix(suffixRows, submittedText);
+  const promptContainsSubmitted =
+    promptSuffixMatchesSubmission(promptRows.map((row) => row.text).join('\n'), submittedText) ||
+    promptSuffixMatchesSubmission(promptRows.map((row) => stripPromptPrefix(row.text)).join('\n'), submittedText);
+  submittedVisible = submittedVisible || promptContainsSubmitted;
+  let agentProgressAfterPrompt = false;
+  if (promptContainsSubmitted) {
+    for (let idx = promptRows.length; idx < suffixRows.length; idx += 1) {
+      const row = suffixRows[idx];
+      const text = row.text.trim();
+      if (!text || isPromptStartLine(text)) continue;
+      if (isAgentProgressLine(text)) {
+        agentProgressAfterPrompt = true;
+        break;
+      }
+      if (isTerminalStatusLine(text)) continue;
+      if (!row.wrapped) {
+        agentProgressAfterPrompt = true;
+        break;
+      }
+    }
+  }
+
+  return {
+    submittedVisible,
+    activePromptVisible: !!(promptContainsSubmitted && !agentProgressAfterPrompt),
+    agentProgressAfterPrompt,
+    lastPromptIndex,
+    rowCount: cleanRows.length,
+  };
+}
+
+function terminalSubmissionAcceptedByMarker(options = {}) {
+  const markerNow = String(options.markerNow || '');
+  const beforeEnterMarker = String(options.beforeEnterMarker || '');
+  if (beforeEnterMarker) {
+    if (markerNow && markerNow !== beforeEnterMarker) {
+      return {
+        accepted: true,
+        reason: 'terminal_output_advanced_after_enter',
+      };
+    }
+    return {
+      accepted: false,
+      reason: '',
+    };
+  }
+
+  const beforeMarker = String(options.beforeMarker || '');
+  if (!options.promptStillVisible && beforeMarker && markerNow && markerNow !== beforeMarker) {
+    return {
+      accepted: true,
+      reason: 'terminal_output_advanced',
+    };
+  }
+
+  return {
+    accepted: false,
+    reason: '',
+  };
+}
+
+module.exports = {
+  bracketedPastePayload,
+  remoteSubmissionWritePayload,
+  isAgentProgressLine,
+  isPromptStartLine,
+  isTerminalStatusLine,
+  normalizeSubmissionText,
+  normalizeTerminalRows,
+  durablePromptMatch,
+  stripAnsi,
+  stripPromptPrefix,
+  submissionTextMatches,
+  timestampMs,
+  terminalRowsPromptText,
+  terminalRowsText,
+  terminalSubmissionAcceptedByMarker,
+  terminalSubmittedPromptState,
+};