switchroom 0.19.12 → 0.19.13

package/telegram-plugin/temporal-normalize.ts

@@ -0,0 +1,347 @@
+/**
+ * temporal-normalize.ts — deterministic outbound temporal normalization (#3501).
+ *
+ * Two independent, idempotent rewrites applied to outbound Telegram prose, in
+ * the shared `normalizeOutboundBody` seam (after redact/punctuation/bold,
+ * before the voice scrub):
+ *
+ *   1. UTC/Zulu datetimes → the agent's LOCAL wall clock. A raw
+ *      `2026-07-23T09:15:00Z` (or `…+00:00`, or a `14:00 UTC` / `2 pm GMT`
+ *      label) is rewritten to `Thu 23 Jul 7:15 pm AEST` — DST-correct by
+ *      construction (Intl resolves the per-instant offset) — so the operator
+ *      never has to translate UTC in their head, and the model can never re-read
+ *      its own outbound as "now in UTC".
+ *
+ *   2. Relative-day accuracy. A relative day word (today / tomorrow / yesterday /
+ *      tonight / this morning|afternoon|evening) written ADJACENT to an absolute
+ *      date is checked against the current date in the agent's configured TZ and
+ *      corrected if wrong. The incident: a cron notification said "closed
+ *      tomorrow (Thu 23 Jul)" when today WAS Thursday 23 Jul — it should read
+ *      "closed today (Thu 23 Jul)". A relative word with NO adjacent absolute
+ *      date is left untouched.
+ *
+ * Design constraints (all enforced here):
+ *   - Pure over its arguments — `tz` and `nowMs` are passed in (callers use
+ *     `resolveEnvTimezone()` and `Date.now()`); NO env / clock read here.
+ *   - Never-throw: a bad/unresolvable IANA `tz` degrades to the INPUT unchanged
+ *     rather than crashing a turn (mirrors `fmtLocalStamp`'s contract).
+ *   - Intl-only: ZERO date libraries — reuses `localDay` / `tzAbbrev` from
+ *     shared/local-time.ts.
+ *   - False-positive guard: code fences, inline code, markdown link hrefs, and
+ *     angle-bracket autolinks are masked before either pass, so an ISO string in
+ *     a log / URL / code span is never rewritten. Blockquote (`>`) lines are
+ *     excluded too — forwarded/quoted third-party text is left verbatim.
+ *   - Idempotent: the UTC output carries no Z/UTC/GMT token (the detector can't
+ *     re-match it); the relative-day output is a fixed point once the word and
+ *     date agree.
+ */
+
+import { localDay, tzAbbrev } from './shared/local-time.js'
+
+// ── Combined false-positive masker ─────────────────────────────────────────
+// Covers the SAME regions normalizePunctuation protects (fenced blocks, inline
+// code, `](href)` link destinations, `<scheme:…>` autolinks) — lifted here as a
+// single shared masker because `maskCodeRegions` (format.ts) alone does NOT
+// cover link hrefs / autolinks (that logic lives inline inside normalizePunctuation).
+interface MaskedRegions {
+  masked: string
+  restore: (s: string) => string
+}
+
+function maskTemporalRegions(text: string): MaskedRegions {
+  const nonce = Math.random().toString(36).slice(2)
+  const PH = `\x00TN${nonce}_`
+  const masks: string[] = []
+  const push = (s: string): string => {
+    masks.push(s)
+    return `${PH}${masks.length - 1}\x00`
+  }
+  const masked = text
+    // Fenced blocks first, only when CLOSED (matching ```), so an unclosed
+    // fence is left intact rather than misparsed by the inline pass.
+    .replace(/```[\s\S]*?```/g, (m) => push(m))
+    // Inline code spans.
+    .replace(/`[^`\n]+`/g, (m) => push(m))
+    // Markdown inline-link DESTINATIONS `](href)` — only the href inside the
+    // parens is masked; the visible label still normalizes like prose.
+    .replace(/(\]\()([^)\n]*)(\))/g, (_m, open: string, href: string, close: string) =>
+      `${open}${push(href)}${close}`,
+    )
+    // GFM angle-bracket autolink destinations `<scheme:…>`.
+    .replace(/(<)([a-zA-Z][a-zA-Z0-9+.-]*:[^>\s]*)(>)/g, (_m, lt: string, uri: string, gt: string) =>
+      `${lt}${push(uri)}${gt}`,
+    )
+  const esc = nonce.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const re = new RegExp(`\x00TN${esc}_(\\d+)\x00`, 'g')
+  const restore = (s: string): string => s.replace(re, (_m, idx: string) => masks[Number(idx)] ?? _m)
+  return { masked, restore }
+}
+
+/** A blockquote line (mirrors format.ts `isBlockquoteLine`). */
+function isBlockquoteLine(line: string): boolean {
+  return line.trimStart().startsWith('>')
+}
+
+/** Run a per-line transform on masked text, leaving blockquote lines verbatim. */
+function perNonQuoteLine(masked: string, fn: (line: string) => string): string {
+  return masked
+    .split('\n')
+    .map((line) => (isBlockquoteLine(line) ? line : fn(line)))
+    .join('\n')
+}
+
+// ── Local rendering ─────────────────────────────────────────────────────────
+
+/** `Thu 23 Jul` — weekday + day + short month in `tz`, no locale punctuation. */
+function renderLocalDate(ms: number, tz: string): string {
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone: tz,
+    weekday: 'short',
+    day: 'numeric',
+    month: 'short',
+  }).formatToParts(new Date(ms))
+  const get = (t: string): string => parts.find((p) => p.type === t)?.value ?? ''
+  return `${get('weekday')} ${get('day')} ${get('month')}`
+}
+
+/** `7:15 pm` — spaced, lowercased am/pm wall clock in `tz`. */
+function renderLocalClock(ms: number, tz: string): string {
+  return new Intl.DateTimeFormat('en-US', {
+    timeZone: tz,
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true,
+  })
+    .format(new Date(ms))
+    .replace(/\s([AP])M$/, (_m, p: string) => ` ${p.toLowerCase()}m`)
+}
+
+/** `Thu 23 Jul 7:15 pm AEST` — full local datetime for a converted instant. */
+function renderLocalDatetime(ms: number, tz: string): string {
+  return `${renderLocalDate(ms, tz)} ${renderLocalClock(ms, tz)} ${tzAbbrev(ms, tz)}`
+}
+
+// ── Pass 1: UTC / Zulu datetime → local ─────────────────────────────────────
+
+// Full ISO-8601 with a Z or +00:00 zero-offset. Seconds + fractional seconds
+// optional. The trailing marker guarantees the output (which carries none)
+// cannot re-match — idempotent by construction.
+const ISO_UTC_RE = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|\+00:00)/g
+
+// Labelled clock time tagged UTC/GMT. The minutes / am|pm are OPTIONAL in the
+// pattern but the replacer REQUIRES at least one of them (colon-minutes OR
+// am/pm) before converting — so a bare "5 GMT" (as in "9 to 5 GMT") is left
+// untouched, matching the tightened grammar.
+const LABELLED_UTC_RE = /\b(\d{1,2})(?::(\d{2}))?\s?(am|pm)?\s?(UTC|GMT)\b/gi
+
+function convertUtcInLine(line: string, tz: string, nowMs: number): string {
+  let out = line.replace(ISO_UTC_RE, (m) => {
+    const ms = Date.parse(m)
+    if (Number.isNaN(ms)) return m
+    return renderLocalDatetime(ms, tz)
+  })
+  out = out.replace(LABELLED_UTC_RE, (m, hh: string, mm: string | undefined, ampm: string | undefined) => {
+    // Tightened grammar: require colon-minutes OR am/pm — reject bare "5 GMT".
+    if (mm == null && ampm == null) return m
+    let h = Number(hh)
+    const pm = ampm != null && /pm/i.test(ampm)
+    if (ampm != null) {
+      if (h > 12) return m // "14 pm" is nonsensical — leave untouched
+      if (h === 12) h = pm ? 12 : 0
+      else if (pm) h += 12
+    }
+    if (h > 23) return m
+    const minute = mm != null ? Number(mm) : 0
+    if (minute > 59) return m
+    const now = new Date(nowMs)
+    // Interpret the labelled time as UTC on nowMs's UTC calendar date, then
+    // render the LOCAL wall clock. No date is emitted (the source carried none).
+    const ms = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), h, minute)
+    return `${renderLocalClock(ms, tz)} ${tzAbbrev(ms, tz)}`
+  })
+  return out
+}
+
+/**
+ * Rewrite UTC/Zulu datetimes in `text` to the local wall clock in `tz`.
+ * Pure / never-throws: an invalid `tz` (or any internal failure) returns the
+ * input unchanged.
+ */
+export function normalizeUtcDatetimes(text: string, tz: string, nowMs: number): string {
+  if (!text) return text
+  try {
+    // Fast-path: nothing that could be a UTC datetime.
+    if (!/\d{4}-\d{2}-\d{2}T|\b(?:UTC|GMT)\b/i.test(text)) return text
+    const { masked, restore } = maskTemporalRegions(text)
+    const out = perNonQuoteLine(masked, (line) => convertUtcInLine(line, tz, nowMs))
+    return restore(out)
+  } catch {
+    return text
+  }
+}
+
+// ── Pass 2: relative-day accuracy ───────────────────────────────────────────
+
+const REL = '(today|tonight|this\\s+morning|this\\s+afternoon|this\\s+evening|tomorrow|yesterday)'
+// A small, strict separator set: whitespace / commas, an optional "on ", and an
+// optional opening paren. Bounded (only spaces/commas), so the effective window
+// stays small — no `.{0,15}` wildcard that could swallow arbitrary prose.
+const SEP = '([\\s,]*(?:on\\s+)?\\(?\\s*)'
+const WD = '(?:mon|tue|wed|thu|fri|sat|sun)[a-z]*'
+const MON = '(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*'
+// One optional weekday token (captured, with its trailing separator), then one
+// absolute-date core (captured whole; re-parsed in the replacer).
+const WD_GROUP = `((?:${WD})[\\s,]+)?`
+const DATE_CORE =
+  `((?:\\d{1,2}\\s+${MON})|(?:${MON}\\s+\\d{1,2})|(?:\\d{4}-\\d{2}-\\d{2})|(?:\\d{1,2}\\/\\d{2}))`
+
+const MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec']
+const WEEKDAY_SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+
+function buildRelRegex(): RegExp {
+  return new RegExp(REL + SEP + WD_GROUP + DATE_CORE, 'gi')
+}
+
+interface ParsedDate {
+  year: number | null
+  month: number // 1-12
+  day: number
+}
+
+/** Parse a matched absolute-date core into {year?, month, day}, or null. */
+function parseDateCore(core: string): ParsedDate | null {
+  let m: RegExpExecArray | null
+  if ((m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(core))) {
+    return { year: Number(m[1]), month: Number(m[2]), day: Number(m[3]) }
+  }
+  if ((m = /^(\d{1,2})\/(\d{2})$/.exec(core))) {
+    // DD/MM (fleet convention — matches the "23/07" nice-to-have).
+    return { year: null, month: Number(m[2]), day: Number(m[1]) }
+  }
+  if ((m = /^(\d{1,2})\s+([a-z]+)$/i.exec(core))) {
+    const mon = MONTHS.indexOf(m[2].slice(0, 3).toLowerCase())
+    if (mon < 0) return null
+    return { year: null, month: mon + 1, day: Number(m[1]) }
+  }
+  if ((m = /^([a-z]+)\s+(\d{1,2})$/i.exec(core))) {
+    const mon = MONTHS.indexOf(m[1].slice(0, 3).toLowerCase())
+    if (mon < 0) return null
+    return { year: null, month: mon + 1, day: Number(m[2]) }
+  }
+  return null
+}
+
+/** UTC-midnight day index for a Y-M-D (calendar-day math, DST-irrelevant). */
+function dayIndex(y: number, mo1: number, d: number): number {
+  return Math.floor(Date.UTC(y, mo1 - 1, d) / 86_400_000)
+}
+
+/** Resolve a possibly-yearless date to the occurrence nearest today-in-tz. */
+function resolveYear(parsed: ParsedDate, todayY: number, todayIdx: number): number {
+  if (parsed.year != null) return parsed.year
+  let best = todayY
+  let bestAbs = Infinity
+  for (const y of [todayY - 1, todayY, todayY + 1]) {
+    const diff = Math.abs(dayIndex(y, parsed.month, parsed.day) - todayIdx)
+    if (diff < bestAbs) {
+      bestAbs = diff
+      best = y
+    }
+  }
+  return best
+}
+
+/** Preserve the original casing pattern of a rewritten day word. */
+function matchCase(sample: string, replacement: string): string {
+  if (sample.length > 0 && sample[0] === sample[0].toUpperCase() && sample[0] !== sample[0].toLowerCase()) {
+    return replacement.charAt(0).toUpperCase() + replacement.slice(1)
+  }
+  return replacement
+}
+
+const TIME_OF_DAY_RE = /^(tonight|this\s+)/i
+
+function rewriteRelativeInLine(line: string, tz: string, nowMs: number): string {
+  const today = localDay(nowMs, tz) // YYYY-MM-DD (throws first on a bad tz)
+  const [ty, tm, td] = today.split('-').map(Number)
+  const todayIdx = dayIndex(ty, tm, td)
+
+  return line.replace(buildRelRegex(), (full, rel: string, sep: string, wdGroup: string | undefined, core: string) => {
+    const parsed = parseDateCore(core)
+    if (parsed == null) return full
+    const year = resolveYear(parsed, ty, todayIdx)
+    const targetIdx = dayIndex(year, parsed.month, parsed.day)
+    const diff = targetIdx - todayIdx
+
+    // Out-of-range (|diff| > 1): leave the ENTIRE match untouched — do NOT
+    // invent a word and do NOT auto-delete (open question 3 resolution).
+    if (diff < -1 || diff > 1) return full
+
+    const isTimeOfDay = TIME_OF_DAY_RE.test(rel)
+
+    // Determine the corrected relative word.
+    let newRel = rel
+    if (isTimeOfDay) {
+      // tonight / this morning|afternoon|evening are a correct SUBSET of today.
+      // Only valid when the date resolves to today (diff==0); never remap them
+      // to bare tomorrow/yesterday. Otherwise leave the whole match untouched.
+      if (diff !== 0) return full
+      // diff==0: the word is already correct — keep it verbatim.
+    } else {
+      const want = diff === 1 ? 'tomorrow' : diff === 0 ? 'today' : 'yesterday'
+      newRel = matchCase(rel, want)
+    }
+
+    // Weekday repair: if a weekday token precedes the date and disagrees with
+    // the true weekday of the resolved date in-tz, correct it.
+    let newWdGroup = wdGroup
+    if (wdGroup != null) {
+      const trueDow = new Date(Date.UTC(year, parsed.month - 1, parsed.day)).getUTCDay()
+      const trueShort = WEEKDAY_SHORT[trueDow]
+      // Preserve the original separator tail after the weekday token.
+      const wdMatch = /^([a-z]+)([\s,]+)$/i.exec(wdGroup)
+      if (wdMatch != null) {
+        const writtenShort = wdMatch[1].slice(0, 3).toLowerCase()
+        if (writtenShort !== trueShort.toLowerCase()) {
+          const wasLong = wdMatch[1].length > 3
+          const corrected = wasLong ? longWeekday(trueDow) : trueShort
+          newWdGroup = matchCase(wdMatch[1], corrected) + wdMatch[2]
+        }
+      }
+    }
+
+    return `${newRel}${sep}${newWdGroup ?? ''}${core}`
+  })
+}
+
+const WEEKDAY_LONG = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+function longWeekday(dow: number): string {
+  return WEEKDAY_LONG[dow]
+}
+
+/**
+ * Correct relative-day words that are wrong for the absolute date they sit next
+ * to, resolved against `nowMs` in `tz`. Pure / never-throws.
+ */
+export function normalizeRelativeDays(text: string, tz: string, nowMs: number): string {
+  if (!text) return text
+  try {
+    if (!/\b(today|tonight|this\s+(?:morning|afternoon|evening)|tomorrow|yesterday)\b/i.test(text)) {
+      return text
+    }
+    const { masked, restore } = maskTemporalRegions(text)
+    const out = perNonQuoteLine(masked, (line) => rewriteRelativeInLine(line, tz, nowMs))
+    return restore(out)
+  } catch {
+    return text
+  }
+}
+
+/**
+ * Convenience composition: UTC→local FIRST (so it produces absolute local
+ * datetimes the relative-day pass can then check), THEN relative-day accuracy.
+ * Pure / never-throws — each sub-pass degrades to its input on failure.
+ */
+export function normalizeTemporal(text: string, tz: string, nowMs: number): string {
+  return normalizeRelativeDays(normalizeUtcDatetimes(text, tz, nowMs), tz, nowMs)
+}

package/telegram-plugin/tests/gateway-outbound-redact.test.ts

@@ -53,29 +53,39 @@ describe('gateway outbound secret-scrub — structural wiring', () => {
     // delegates via `normalizeOutboundBody(rawText, 'reply', redactOutboundText)`
     // — the injected redactor still runs at entry, before the stderr preview.
     const start = sendPathSrc.indexOf('export async function sendReply(')
-    const redactIdx = sendPathSrc.indexOf(`normalizeOutboundBody(rawText, 'reply', redactOutboundText)`, start)
+    const redactIdx = sendPathSrc.indexOf(`normalizeOutboundBody(rawText, 'reply', redactOutboundText`, start)
     const previewIdx = sendPathSrc.indexOf('reply: invoked chatId=', start)
     expect(start).toBeGreaterThan(0)
     expect(redactIdx).toBeGreaterThan(start)
     expect(previewIdx).toBeGreaterThan(redactIdx) // mask BEFORE the preview is logged
   })
 
-  it('edit_message: scrubs at entry, before the voice scrub + send', () => {
+  it('edit_message: scrubs via the shared seam at entry, before the send (#3501)', () => {
+    // #3501: edit_message routes through normalizeOutboundBody, passing the
+    // injected redactor with the 'edit_message' site. The seam runs redact
+    // internally (pinned in outbound-send-path.ts), so the mask still fires at
+    // entry — before the editMessageText send below.
     const start = src.indexOf('async function executeEditMessage(')
-    const redactIdx = src.indexOf(`redactOutboundText(editRawText, 'edit_message')`, start)
-    const scrubIdx = src.indexOf(`site: 'edit_message'`, start)
+    const seamIdx = src.indexOf(`'edit_message',`, start)
+    const redactArgIdx = src.indexOf('redactOutboundText,', seamIdx)
+    const sendIdx = src.indexOf('editMessageText(', start)
     expect(start).toBeGreaterThan(0)
-    expect(redactIdx).toBeGreaterThan(start)
-    expect(scrubIdx).toBeGreaterThan(redactIdx)
+    expect(seamIdx).toBeGreaterThan(start)
+    expect(redactArgIdx).toBeGreaterThan(seamIdx) // redactor passed into the seam
+    expect(sendIdx).toBeGreaterThan(redactArgIdx) // mask BEFORE the send
   })
 
-  it('turn-flush backstop: scrubs the model terminal prose before send', () => {
+  it('turn-flush backstop: scrubs the model terminal prose before send (#3501)', () => {
     // Turn-flush delivers the model's answer when it skipped reply/stream_reply
-    // — arbitrary agent free-text that hits the wire + stderr preview.
-    const redactIdx = streamSrc.indexOf(`redactOutboundText(capturedText, 'turn_flush')`)
-    const scrubSiteIdx = streamSrc.indexOf(`site: 'turn_flush'`)
-    expect(redactIdx).toBeGreaterThan(0)
-    expect(scrubSiteIdx).toBeGreaterThan(redactIdx) // mask BEFORE the voice scrub + send
+    // — arbitrary agent free-text that hits the wire + stderr preview. #3501:
+    // it routes through normalizeOutboundBody('turn_flush', redactOutboundText),
+    // which redacts internally before the voice-scrub + send.
+    const seamIdx = streamSrc.indexOf('normalizeOutboundBody(')
+    const siteIdx = streamSrc.indexOf(`'turn_flush',`, seamIdx)
+    const redactArgIdx = streamSrc.indexOf('redactOutboundText,', seamIdx)
+    expect(seamIdx).toBeGreaterThan(0)
+    expect(siteIdx).toBeGreaterThan(seamIdx) // seam invoked with the turn_flush site
+    expect(redactArgIdx).toBeGreaterThan(seamIdx) // redactor passed into the seam
   })
 
   it('progress_update: scrubs at entry, BEFORE the 300-char truncation', () => {

package/telegram-plugin/tests/outbound-send-path.test.ts

@@ -79,6 +79,46 @@ function referenceResplit(chunk: string): string[] {
 
 const injectedRedact = (text: string, _site: string): string => redact(text)
 
+// ── Verbatim inline reference for the FORMER edit_message pipeline ──────────
+// (executeEditMessage, pre-#3501): repair → [paragraph-break if !literal] →
+// redact → [addParagraphSpacers(stripExcessBold(normalizePunctuation)) if
+// !literal] → voice scrub. Consolidated into normalizeOutboundBody's
+// {literalText, addSpacers} options; this reference pins byte-equivalence.
+function referenceEditNormalize(
+  rawText: string,
+  literalText: boolean,
+): { text: string; voiceReplaced: number } {
+  let editRawText = repairEscapedWhitespace(rawText)
+  if (!literalText) editRawText = normalizeParagraphBreaks(editRawText)
+  editRawText = redact(editRawText)
+  if (!literalText) editRawText = addParagraphSpacers(stripExcessBold(normalizePunctuation(editRawText)))
+  let voiceReplaced = 0
+  const scrub = scrubVoice(editRawText)
+  if (scrub.replaced > 0) {
+    editRawText = scrub.scrubbed
+    voiceReplaced = scrub.replaced
+  }
+  return { text: editRawText, voiceReplaced }
+}
+
+// ── Verbatim inline reference for the FORMER turn-flush pipeline ────────────
+// (stream-render.ts turn-flush branch, pre-#3501): normalizeParagraphBreaks(
+// repairEscapedWhitespace) → redact('turn_flush') → stripExcessBold(
+// normalizePunctuation) → voice scrub. This is normalizeOutboundBody's DEFAULT
+// shape — identical to the reply pipeline. Consolidated to a single call.
+function referenceTurnFlushNormalize(rawText: string): { text: string; voiceReplaced: number } {
+  let text = normalizeParagraphBreaks(repairEscapedWhitespace(rawText))
+  text = redact(text)
+  text = stripExcessBold(normalizePunctuation(text))
+  let voiceReplaced = 0
+  const scrub = scrubVoice(text)
+  if (scrub.replaced > 0) {
+    text = scrub.scrubbed
+    voiceReplaced = scrub.replaced
+  }
+  return { text, voiceReplaced }
+}
+
 // ── Representative outbound fixtures ────────────────────────────────────────
 
 const FIXTURES: Record<string, string> = {
@@ -121,6 +161,73 @@ describe('outbound-send-path — normalizeOutboundBody parity with inline pipeli
   })
 })
 
+// #3501 — the edit_message and turn-flush sites were hand-mirrored inline
+// pipelines that now route through normalizeOutboundBody. These pin that the
+// {literalText, addSpacers} options reproduce the former inline output
+// byte-for-byte, so the consolidation is provably behaviour-neutral.
+describe('outbound-send-path — edit_message option parity (#3501)', () => {
+  for (const [name, raw] of Object.entries(FIXTURES)) {
+    it(`rich edit (addSpacers) byte-identical: ${name}`, () => {
+      const ref = referenceEditNormalize(raw, false)
+      const got = normalizeOutboundBody(raw, 'edit_message', injectedRedact, {
+        literalText: false,
+        addSpacers: true,
+      })
+      expect(got.text).toBe(ref.text)
+      expect(got.voiceReplaced).toBe(ref.voiceReplaced)
+    })
+
+    it(`literal edit (literalText) byte-identical: ${name}`, () => {
+      const ref = referenceEditNormalize(raw, true)
+      const got = normalizeOutboundBody(raw, 'edit_message', injectedRedact, {
+        literalText: true,
+        addSpacers: false,
+      })
+      expect(got.text).toBe(ref.text)
+      expect(got.voiceReplaced).toBe(ref.voiceReplaced)
+    })
+  }
+
+  it('literal edit skips paragraph/punctuation/bold/spacer formatting', () => {
+    // A literal edit must NOT promote lone newlines, strip bold, or add
+    // spacers — only repair + redact + voice scrub run.
+    const raw = 'First line.\nSecond line with **bold** kept.'
+    const got = normalizeOutboundBody(raw, 'edit_message', injectedRedact, {
+      literalText: true,
+    })
+    expect(got.text).toBe(raw) // no transform touched it
+  })
+
+  it('rich edit DOES add the U+00A0 paragraph spacer that reply omits', () => {
+    const raw = FIXTURES.multiParagraph
+    const richEdit = normalizeOutboundBody(raw, 'edit_message', injectedRedact, {
+      addSpacers: true,
+    }).text
+    const reply = normalizeOutboundBody(raw, 'reply', injectedRedact).text
+    // The edit path folds addParagraphSpacers in; the reply path does not.
+    expect(richEdit).toBe(addParagraphSpacers(reply))
+    expect(richEdit).not.toBe(reply)
+  })
+})
+
+describe('outbound-send-path — turn_flush option parity (#3501)', () => {
+  for (const [name, raw] of Object.entries(FIXTURES)) {
+    it(`turn-flush default byte-identical: ${name}`, () => {
+      const ref = referenceTurnFlushNormalize(raw)
+      const got = normalizeOutboundBody(raw, 'turn_flush', injectedRedact)
+      expect(got.text).toBe(ref.text)
+      expect(got.voiceReplaced).toBe(ref.voiceReplaced)
+    })
+  }
+
+  it('turn-flush default equals the reply pipeline (same shape)', () => {
+    const raw = FIXTURES.emDashes
+    const flush = normalizeOutboundBody(raw, 'turn_flush', injectedRedact).text
+    const reply = normalizeOutboundBody(raw, 'reply', injectedRedact).text
+    expect(flush).toBe(reply)
+  })
+})
+
 describe('outbound-send-path — effective text + chunk parity', () => {
   for (const [name, raw] of Object.entries(FIXTURES)) {
     for (const literalText of [true, false]) {
@@ -222,3 +329,87 @@ describe('outbound-send-path — cross-surface dedup suppression', () => {
     expect(dedup.check(chatId, undefined, text, t0 + 500, 'turn-2')).toBeNull()
   })
 })
+
+// ── #3501 temporal-normalization wiring into the shared seam ────────────────
+import { readFileSync } from 'node:fs'
+import { normalizeTemporal } from '../temporal-normalize.js'
+
+const TZ_MEL = 'Australia/Melbourne'
+const NOW_THU = Date.UTC(2026, 6, 23, 2, 0, 0) // Thu 2026-07-23 midday Melbourne
+
+describe('outbound-send-path — temporal pass wiring (#3501)', () => {
+  it('fires when tz+nowMs are supplied — fixes the cron/mail-watcher incident', () => {
+    const incident = 'Heads up: the office is closed tomorrow (Thu 23 Jul).'
+    const got = normalizeOutboundBody(incident, 'turn_flush', injectedRedact, {
+      tz: TZ_MEL,
+      nowMs: NOW_THU,
+    })
+    expect(got.text).toBe('Heads up: the office is closed today (Thu 23 Jul).')
+  })
+
+  it('is a NO-OP when tz is omitted (keeps the seam pure/clock-free by default)', () => {
+    const incident = 'closed tomorrow (Thu 23 Jul)'
+    // No tz → temporal must not fire; output is the plain formatted pipeline.
+    const got = normalizeOutboundBody(incident, 'reply', injectedRedact)
+    expect(got.text).toBe(incident)
+  })
+
+  it('REVIEW FIX 3 — a literal edit does NOT run the temporal pass', () => {
+    const incident = 'closed tomorrow (Thu 23 Jul)'
+    const got = normalizeOutboundBody(incident, 'edit_message', injectedRedact, {
+      literalText: true,
+      tz: TZ_MEL,
+      nowMs: NOW_THU,
+    })
+    // Literal edit lands byte-for-byte — the stale relative word is preserved.
+    expect(got.text).toBe(incident)
+  })
+
+  it('golden pipeline ORDER — temporal output is not mangled by the voice scrub', () => {
+    // A UTC datetime is rewritten to "Thu 23 Jul 7:15 pm AEST"; the voice scrub
+    // (em/en dash → comma) that runs AFTER must not touch it.
+    const raw = 'window 2026-07-23T09:15:00Z opens'
+    const got = normalizeOutboundBody(raw, 'reply', injectedRedact, {
+      tz: TZ_MEL,
+      nowMs: NOW_THU,
+    })
+    expect(got.text).toBe('window Thu 23 Jul 7:15 pm AEST opens')
+  })
+
+  it('temporal runs AFTER punctuation/bold and BEFORE scrubVoice (structural pin)', () => {
+    const src = readFileSync(new URL('../gateway/outbound-send-path.ts', import.meta.url), 'utf8')
+    const start = src.indexOf('export function normalizeOutboundBody(')
+    const boldIdx = src.indexOf('stripExcessBold(normalizePunctuation(text))', start)
+    const temporalIdx = src.indexOf('normalizeTemporal(text, tz, nowMs)', start)
+    const scrubIdx = src.indexOf('scrubVoice(text)', start)
+    expect(boldIdx).toBeGreaterThan(start)
+    expect(temporalIdx).toBeGreaterThan(boldIdx) // AFTER punctuation/bold
+    expect(scrubIdx).toBeGreaterThan(temporalIdx) // BEFORE the voice scrub
+  })
+
+  it('per-site wiring pin — all three prose sends pass tz+nowMs into the seam', () => {
+    const sendPath = readFileSync(new URL('../gateway/outbound-send-path.ts', import.meta.url), 'utf8')
+    const gateway = readFileSync(new URL('../gateway/gateway.ts', import.meta.url), 'utf8')
+    const streamRender = readFileSync(new URL('../gateway/stream-render.ts', import.meta.url), 'utf8')
+    // Reply site (sendReply) passes tz+nowMs.
+    const replyStart = sendPath.indexOf(`normalizeOutboundBody(rawText, 'reply', redactOutboundText`)
+    expect(replyStart).toBeGreaterThan(0)
+    expect(sendPath.indexOf('tz: resolveEnvTimezone()', replyStart)).toBeGreaterThan(replyStart)
+    // edit_message site passes tz+nowMs.
+    const editStart = gateway.indexOf(`'edit_message',`)
+    expect(gateway.indexOf('tz: resolveEnvTimezone()', editStart)).toBeGreaterThan(editStart)
+    // turn-flush site passes tz+nowMs.
+    const flushStart = streamRender.indexOf(`'turn_flush',`)
+    expect(streamRender.indexOf('tz: resolveEnvTimezone()', flushStart)).toBeGreaterThan(flushStart)
+  })
+
+  it('temporal wiring matches the standalone module output (no drift)', () => {
+    const raw = 'ships tomorrow (Thu 23 Jul), at 2026-07-23T09:15:00Z'
+    const viaSeam = normalizeOutboundBody(raw, 'reply', injectedRedact, {
+      tz: TZ_MEL,
+      nowMs: NOW_THU,
+    }).text
+    const viaModule = normalizeTemporal(raw, TZ_MEL, NOW_THU)
+    expect(viaSeam).toBe(viaModule)
+  })
+})