switchroom 0.14.40 → 0.14.41

package/dist/cli/switchroom.js

@@ -49462,8 +49462,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.40";
-var COMMIT_SHA = "d2d69140";
+var VERSION = "0.14.41";
+var COMMIT_SHA = "747ab2f1";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.40",
+  "version": "0.14.41",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/telegram-plugin/dist/gateway/gateway.js

@@ -47263,11 +47263,17 @@ function decideInboundDelivery(input) {
 function createDeliveryQueue() {
   return { pending: new Map };
 }
-function trackDelivery(q, key, inbound, now) {
-  q.pending.set(key, { key, inbound, lastAttemptAt: now });
+function trackDelivery(q, key, inbound, now, messageId = null) {
+  q.pending.set(key, { key, inbound, messageId, lastAttemptAt: now });
 }
-function ackDelivery(q, key) {
-  return q.pending.delete(key);
+function ackDelivery(q, key, enqueueMessageId = null) {
+  const entry = q.pending.get(key);
+  if (!entry)
+    return false;
+  if (entry.messageId != null && entry.messageId !== enqueueMessageId)
+    return false;
+  q.pending.delete(key);
+  return true;
 }
 function sweep(q, now, timeoutMs) {
   const redeliver = [];
@@ -47282,6 +47288,15 @@ function sweep(q, now, timeoutMs) {
 function forgetDelivery(q, key) {
   q.pending.delete(key);
 }
+function shouldTrackDelivery(input) {
+  if (input.isSteering || input.isInterrupt)
+    return false;
+  if (input.hasSource)
+    return false;
+  if (input.effectiveText !== undefined && input.effectiveText.trim().length === 0)
+    return false;
+  return true;
+}
 
 // gateway/pending-permission-decisions.ts
 var DEFAULT_PENDING_PERMISSION_CAP = 32;
@@ -51850,10 +51865,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.40";
-var COMMIT_SHA = "d2d69140";
-var COMMIT_DATE = "2026-06-02T08:59:46Z";
-var LATEST_PR = 2090;
+var VERSION = "0.14.41";
+var COMMIT_SHA = "747ab2f1";
+var COMMIT_DATE = "2026-06-02T11:03:39Z";
+var LATEST_PR = 2095;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -53028,7 +53043,9 @@ function markClaudeBusyForInbound(m) {
   return key;
 }
 var DELIVERY_CONFIRM_ENABLED = process.env.SWITCHROOM_INBOUND_DELIVERY_CONFIRM !== "0";
-var DELIVERY_CONFIRM_TIMEOUT_MS = Number(process.env.SWITCHROOM_INBOUND_DELIVERY_TIMEOUT_MS) || 15000;
+var _deliveryTimeoutRaw = process.env.SWITCHROOM_INBOUND_DELIVERY_TIMEOUT_MS;
+var _deliveryTimeoutParsed = _deliveryTimeoutRaw != null && _deliveryTimeoutRaw !== "" ? Number(_deliveryTimeoutRaw) : 15000;
+var DELIVERY_CONFIRM_TIMEOUT_MS = Number.isFinite(_deliveryTimeoutParsed) && _deliveryTimeoutParsed > 0 ? _deliveryTimeoutParsed : 15000;
 var DELIVERY_CONFIRM_SWEEP_MS = 5000;
 var deliveryQueue = createDeliveryQueue();
 function turnInFlightForGate() {
@@ -54160,7 +54177,12 @@ async function redeliverStrandedInbound(p) {
       clearAgentComposer2({ agentName: selfAgent });
   } catch {}
   const ok = ipcServer.sendToAgent(selfAgent, p.inbound);
-  if (!ok) {
+  if (ok) {
+    markClaudeBusyForInbound(p.inbound);
+    if (!deliveryQueue.pending.has(p.key)) {
+      trackDelivery(deliveryQueue, p.key, p.inbound, Date.now(), p.messageId);
+    }
+  } else {
     pendingInboundBuffer.push(selfAgent, p.inbound);
     forgetDelivery(deliveryQueue, p.key);
   }
@@ -54168,6 +54190,10 @@ async function redeliverStrandedInbound(p) {
 var _deliveryConfirmSweep = setInterval(() => {
   if (!DELIVERY_CONFIRM_ENABLED)
     return;
+  if (currentTurn != null)
+    return;
+  if (pendingPermissions.size > 0 || pendingAskUser.size > 0)
+    return;
   for (const p of sweep(deliveryQueue, Date.now(), DELIVERY_CONFIRM_TIMEOUT_MS)) {
     redeliverStrandedInbound(p);
   }
@@ -56564,7 +56590,7 @@ function handleSessionEvent(ev) {
         };
         currentTurn = next;
         if (DELIVERY_CONFIRM_ENABLED) {
-          ackDelivery(deliveryQueue, chatKey2(ev.chatId, ev.threadId != null ? Number(ev.threadId) : null));
+          ackDelivery(deliveryQueue, chatKey2(ev.chatId, ev.threadId != null ? Number(ev.threadId) : null), ev.messageId);
         }
         shadowEmit({
           kind: "turnStart",
@@ -58000,12 +58026,24 @@ ${preBlock(write.output)}`;
   const delivered = ipcServer.sendToAgent(selfAgent, inboundMsg);
   if (delivered) {
     const busyKey = markClaudeBusyForInbound(inboundMsg);
-    if (DELIVERY_CONFIRM_ENABLED) {
-      trackDelivery(deliveryQueue, busyKey, inboundMsg, Date.now());
+    if (DELIVERY_CONFIRM_ENABLED && shouldTrackDelivery({
+      isSteering,
+      isInterrupt: interrupt.isInterrupt,
+      hasSource: inboundMsg.meta?.source != null,
+      effectiveText
+    })) {
+      trackDelivery(deliveryQueue, busyKey, inboundMsg, Date.now(), String(inboundMsg.messageId));
     }
   }
   if (!delivered) {
-    pendingInboundBuffer.push(selfAgent, inboundMsg);
+    if (shouldTrackDelivery({
+      isSteering,
+      isInterrupt: interrupt.isInterrupt,
+      hasSource: inboundMsg.meta?.source != null,
+      effectiveText
+    })) {
+      pendingInboundBuffer.push(selfAgent, inboundMsg);
+    }
     const threadOpts = messageThreadId != null ? { message_thread_id: messageThreadId } : {};
     swallowingApiCall(() => bot.api.sendMessage(chat_id, "\u23F3 Agent is restarting \u2014 your message is queued and will be processed when it reconnects.", { ...threadOpts }), {
       chat_id,

package/telegram-plugin/gateway/gateway.ts

@@ -286,6 +286,7 @@ import {
   ackDelivery,
   sweep as sweepDeliveryQueue,
   forgetDelivery,
+  shouldTrackDelivery,
   type PendingDelivery,
 } from './inbound-delivery-confirm.js'
 import { createPendingPermissionBuffer } from './pending-permission-decisions.js'
@@ -1342,7 +1343,15 @@ const DELIVERY_CONFIRM_ENABLED = process.env.SWITCHROOM_INBOUND_DELIVERY_CONFIRM
 // a clean delivery, so 15s won't false-positive on a healthy turn. Tunable
 // (env) for tests/forensics; a too-low value re-delivers healthy slow turns
 // (duplicate turn), which is why the default is comfortably above ack latency.
-const DELIVERY_CONFIRM_TIMEOUT_MS = Number(process.env.SWITCHROOM_INBOUND_DELIVERY_TIMEOUT_MS) || 15_000
+const _deliveryTimeoutRaw = process.env.SWITCHROOM_INBOUND_DELIVERY_TIMEOUT_MS
+const _deliveryTimeoutParsed =
+  _deliveryTimeoutRaw != null && _deliveryTimeoutRaw !== '' ? Number(_deliveryTimeoutRaw) : 15_000
+// Clamp to a positive, finite value: a negative / zero / NaN env override would
+// make the sweep treat every tracked entry as stranded and re-deliver every
+// cycle forever (a self-inflicted re-delivery loop). To disable the feature,
+// use SWITCHROOM_INBOUND_DELIVERY_CONFIRM=0, not a degenerate timeout.
+const DELIVERY_CONFIRM_TIMEOUT_MS =
+  Number.isFinite(_deliveryTimeoutParsed) && _deliveryTimeoutParsed > 0 ? _deliveryTimeoutParsed : 15_000
 const DELIVERY_CONFIRM_SWEEP_MS = 5_000
 const deliveryQueue = createDeliveryQueue<InboundMessage>()
 
@@ -4106,7 +4115,16 @@ async function redeliverStrandedInbound(p: PendingDelivery<InboundMessage>): Pro
     if (selfAgent) clearAgentComposer({ agentName: selfAgent })
   } catch { /* best-effort; re-deliver regardless */ }
   const ok = ipcServer.sendToAgent(selfAgent, p.inbound)
-  if (!ok) {
+  if (ok) {
+    // Keep the #1556 gate coherent with the re-sent delivery, and survive an
+    // ack that raced the `await import` above: only `enqueue` clears tracking,
+    // so if a concurrent ack removed the entry, re-affirm it — never drop.
+    // Both ops are idempotent.
+    markClaudeBusyForInbound(p.inbound)
+    if (!deliveryQueue.pending.has(p.key)) {
+      trackDelivery(deliveryQueue, p.key, p.inbound, Date.now(), p.messageId)
+    }
+  } else {
     // Bridge offline between attempts — hand off to the offline buffer
     // (bridgeUp drains it) and stop tracking here; the spool owns it now.
     pendingInboundBuffer.push(selfAgent, p.inbound)
@@ -4115,6 +4133,16 @@ async function redeliverStrandedInbound(p: PendingDelivery<InboundMessage>): Pro
 }
 const _deliveryConfirmSweep = setInterval(() => {
   if (!DELIVERY_CONFIRM_ENABLED) return
+  // Re-deliver ONLY when claude is genuinely idle. `currentTurn` is set solely
+  // by the enqueue session-event and nulled at turn-end, so `currentTurn != null`
+  // means a real turn is in flight — re-clearing the composer + re-sending now
+  // would clobber it (the exact mid-turn wedge this queue exists to prevent). A
+  // pending permission / ask_user prompt is likewise a live interaction. Defer:
+  // leave the entry pending (it isn't acked) so the next idle sweep retries.
+  // NB: claudeBusyKeys (turnInFlightForGate) is set EAGERLY at delivery and
+  // stays set through a strand, so it is NOT a usable "idle" signal here.
+  if (currentTurn != null) return
+  if (pendingPermissions.size > 0 || pendingAskUser.size > 0) return
   for (const p of sweepDeliveryQueue(deliveryQueue, Date.now(), DELIVERY_CONFIRM_TIMEOUT_MS)) {
     void redeliverStrandedInbound(p)
   }
@@ -7945,9 +7973,14 @@ function handleSessionEvent(ev: SessionEvent): void {
         // re-delivery. `enqueue` carries the same chat/thread the inbound was
         // keyed on, so the key matches.
         if (DELIVERY_CONFIRM_ENABLED) {
+          // Match on the source message id: `enqueue` fires for EVERY turn
+          // start (cron / subagent-handback / vault-resume / restart-marker
+          // too — see comment below), so a key-only ack would let a synthetic
+          // turn clear a real user message still waiting under the same key.
           ackDelivery(
             deliveryQueue,
             chatKey(ev.chatId, ev.threadId != null ? Number(ev.threadId) : null),
+            ev.messageId,
           )
         }
         // PR3b-cutover: feed the authoritative turn-start to the delivery
@@ -10670,13 +10703,40 @@ async function handleInbound(
     const busyKey = markClaudeBusyForInbound(inboundMsg)
     // Track until claude acks via `enqueue` (the marko drop-wedge): if no ack
     // lands, the message stranded in the composer and the sweep re-delivers
-    // it. See inbound-delivery-confirm.ts.
-    if (DELIVERY_CONFIRM_ENABLED) {
-      trackDelivery(deliveryQueue, busyKey, inboundMsg, Date.now())
+    // it. Track ONLY messages that produce an `enqueue` to ack against —
+    // shouldTrackDelivery excludes steering / `!` interrupt (amend the running
+    // turn), synthetic (meta.source) inbounds, and empty bodies, all of which
+    // never enqueue and would re-deliver forever. The tracked messageId lets
+    // the ack match only THIS message's enqueue (not a synthetic turn sharing
+    // the key). See shouldTrackDelivery / ackDelivery (inbound-delivery-confirm.ts).
+    if (
+      DELIVERY_CONFIRM_ENABLED &&
+      shouldTrackDelivery({
+        isSteering,
+        isInterrupt: interrupt.isInterrupt,
+        hasSource: inboundMsg.meta?.source != null,
+        effectiveText,
+      })
+    ) {
+      trackDelivery(deliveryQueue, busyKey, inboundMsg, Date.now(), String(inboundMsg.messageId))
     }
   }
   if (!delivered) {
-    pendingInboundBuffer.push(selfAgent, inboundMsg)
+    // Only persist fresh user turns to the durable spool. Steering / `!`
+    // interrupt / empty bodies are mid-turn amendments or no-ops that would
+    // arrive orphaned if replayed as a fresh turn after a restart — drop them
+    // (the restart notice below tells the user to re-send). Mirrors the
+    // tracking + #1556-gate carve-outs.
+    if (
+      shouldTrackDelivery({
+        isSteering,
+        isInterrupt: interrupt.isInterrupt,
+        hasSource: inboundMsg.meta?.source != null,
+        effectiveText,
+      })
+    ) {
+      pendingInboundBuffer.push(selfAgent, inboundMsg)
+    }
     const threadOpts = messageThreadId != null ? { message_thread_id: messageThreadId } : {}
     // #1075: thread-id-bearing — swallow via robustApiCall so a deleted
     // topic doesn't crash the gateway. Fire-and-forget; the inbound is

package/telegram-plugin/gateway/inbound-delivery-confirm.ts

@@ -35,6 +35,14 @@ export interface PendingDelivery<M> {
   readonly key: string
   /** The exact inbound to re-send until claude acks it. */
   readonly inbound: M
+  /**
+   * Source message id of the tracked inbound (stringified Telegram
+   * `message_id`), or null if unknown. The `enqueue` ack matches on THIS so a
+   * synthetic-source turn (cron / resume / vault / reaction) that shares the
+   * chatKey can't false-ack — and silently drop — a real user message still
+   * waiting to land. See ackDelivery.
+   */
+  readonly messageId: string | null
   /** When the latest delivery attempt was made (unix-ms). */
   lastAttemptAt: number
 }
@@ -51,22 +59,44 @@ export function createDeliveryQueue<M>(): DeliveryQueue<M> {
  * Track a freshly-delivered inbound, awaiting claude's `enqueue` ack.
  * Overwrites any prior pending for the key — the #1556 gate serialises per
  * key, so a later inbound supersedes an earlier un-acked one for that key.
+ * `messageId` (stringified Telegram message_id) lets the ack match only the
+ * enqueue that belongs to THIS message; pass null when unknown.
  */
 export function trackDelivery<M>(
   q: DeliveryQueue<M>,
   key: string,
   inbound: M,
   now: number,
+  messageId: string | null = null,
 ): void {
-  q.pending.set(key, { key, inbound, lastAttemptAt: now })
+  q.pending.set(key, { key, inbound, messageId, lastAttemptAt: now })
 }
 
 /**
- * Ack a delivery — call from the `enqueue` session-event (claude started the
- * turn, so the message landed). Returns true if a pending entry was cleared.
+ * Ack a delivery — call from the `enqueue` session-event (claude started a
+ * turn). `enqueue` fires for EVERY turn start regardless of source (user
+ * inbound, cron, subagent-handback, vault-resume, restart-marker), so acking
+ * purely by chatKey would let a synthetic-source turn clear — and thus
+ * silently drop — a real user message still waiting under the same key. So
+ * ack ONLY when the enqueue's source message id matches the tracked one.
+ *
+ * Matching rule: if we recorded a messageId for the pending entry, require the
+ * enqueue's `enqueueMessageId` to equal it. If we never recorded one (legacy /
+ * defensive null), fall back to key-only ack. Returns true if an entry was
+ * cleared.
  */
-export function ackDelivery<M>(q: DeliveryQueue<M>, key: string): boolean {
-  return q.pending.delete(key)
+export function ackDelivery<M>(
+  q: DeliveryQueue<M>,
+  key: string,
+  enqueueMessageId: string | null = null,
+): boolean {
+  const entry = q.pending.get(key)
+  if (!entry) return false
+  // A different message started this turn — don't ack ours (it may still be
+  // waiting to land; the sweep will re-deliver it if it stranded).
+  if (entry.messageId != null && entry.messageId !== enqueueMessageId) return false
+  q.pending.delete(key)
+  return true
 }
 
 /**
@@ -94,3 +124,37 @@ export function sweep<M>(
 export function forgetDelivery<M>(q: DeliveryQueue<M>, key: string): void {
   q.pending.delete(key)
 }
+
+/**
+ * Should this delivered inbound be tracked for ack/re-delivery?
+ *
+ * Track a delivery iff it is a fresh user turn that will produce exactly one
+ * `enqueue` to ack against. Everything that does NOT enqueue must be excluded,
+ * or the sweep re-delivers it forever (re-clearing the composer every cycle):
+ *
+ *   - `isSteering` / `isInterrupt` — the #1556 gate's carve-outs: delivered
+ *     mid-turn to AMEND the running turn, so they never start a fresh turn and
+ *     never emit `enqueue`.
+ *   - `hasSource` — synthetic inbounds (cron / vault-resume / subagent-handback
+ *     / reaction) carry a `meta.source`; they enqueue under their own semantics
+ *     and must never be tracked as if they were a queued user turn.
+ *   - empty `effectiveText` — an empty body (e.g. `/queue` with no text) is
+ *     silently dropped by claude's auto-submit and never enqueues, so tracking
+ *     it is a pure re-delivery loop (a self-inflicted DoS on the queue).
+ *
+ * Mirror the gate's carve-outs here so tracking is exactly the set of messages
+ * that produce an `enqueue`.
+ */
+export function shouldTrackDelivery(input: {
+  isSteering: boolean
+  isInterrupt: boolean
+  hasSource?: boolean
+  effectiveText?: string
+}): boolean {
+  if (input.isSteering || input.isInterrupt) return false
+  if (input.hasSource) return false
+  // Gate on empty text only when the caller actually provided it (undefined =
+  // "not supplied", left untracked-gated so existing callers keep their behaviour).
+  if (input.effectiveText !== undefined && input.effectiveText.trim().length === 0) return false
+  return true
+}

package/telegram-plugin/tests/inbound-delivery-confirm.test.ts

@@ -4,6 +4,7 @@ import {
   ackDelivery,
   createDeliveryQueue,
   forgetDelivery,
+  shouldTrackDelivery,
   sweep,
   trackDelivery,
   type DeliveryQueue,
@@ -107,3 +108,73 @@ describe('inbound-delivery-confirm (reliable deliver-until-acked queue)', () =>
     expect(sweep(q, 999_999, TIMEOUT)).toHaveLength(0)
   })
 })
+
+// Regression for the cross-source ACK collision (silent drop): `enqueue` fires
+// for EVERY turn start regardless of source. A synthetic-source turn (cron /
+// resume / vault / reaction) that shares the chatKey of a real user message
+// still waiting to land would, with a key-only ack, clear — and silently drop
+// — that user message. The ack must match on the tracked message id.
+describe('ackDelivery — message-id-matched (cross-source false-ack guard)', () => {
+  it('acks when the enqueue message id matches the tracked one', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'real user msg' }, 0, '5001')
+    expect(ackDelivery(q, 'chat:_', '5001')).toBe(true)
+    expect(q.pending.size).toBe(0)
+  })
+
+  it('does NOT ack when a different (synthetic-source) turn enqueues under the same key', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'real user msg' }, 0, '5001')
+    // a cron / resume turn for the same chat enqueues first, with its own id
+    expect(ackDelivery(q, 'chat:_', '1716123456789')).toBe(false)
+    // the user message is still tracked — it strands → gets re-delivered, not dropped
+    expect(q.pending.size).toBe(1)
+    expect(sweep(q, 15_000, TIMEOUT)).toHaveLength(1)
+    // and its own enqueue (matching id) later acks it cleanly
+    expect(ackDelivery(q, 'chat:_', '5001')).toBe(true)
+    expect(q.pending.size).toBe(0)
+  })
+
+  it('does NOT ack when the enqueue carries no message id but the tracked one has one', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'real user msg' }, 0, '5001')
+    expect(ackDelivery(q, 'chat:_', null)).toBe(false)
+    expect(q.pending.size).toBe(1)
+  })
+
+  it('falls back to key-only ack when no message id was recorded (legacy/defensive)', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'x' }, 0) // no messageId
+    expect(ackDelivery(q, 'chat:_', '5001')).toBe(true)
+    expect(q.pending.size).toBe(0)
+  })
+})
+
+// Regression for the steer/interrupt re-delivery loop: steering and `!`
+// interrupt inbounds amend the running turn and never emit `enqueue`, so they
+// must NOT be tracked (else the sweep re-delivers them forever). Only
+// fresh-turn messages — which DO enqueue — are tracked.
+describe('shouldTrackDelivery — only fresh-turn messages are tracked', () => {
+  it('tracks a normal (non-steering, non-interrupt) message', () => {
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: false })).toBe(true)
+  })
+  it('does NOT track a /steer message (amends the turn — never acks)', () => {
+    expect(shouldTrackDelivery({ isSteering: true, isInterrupt: false })).toBe(false)
+  })
+  it('does NOT track a ! interrupt message (amends the turn — never acks)', () => {
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: true })).toBe(false)
+  })
+  it('does NOT track when both flags set (defensive)', () => {
+    expect(shouldTrackDelivery({ isSteering: true, isInterrupt: true })).toBe(false)
+  })
+  it('does NOT track a synthetic (meta.source) inbound — cron/resume/vault/reaction enqueue under their own semantics', () => {
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: false, hasSource: true })).toBe(false)
+  })
+  it('does NOT track an empty-body message (e.g. `/queue` with no text) — never enqueues, would re-deliver forever', () => {
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: false, effectiveText: '' })).toBe(false)
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: false, effectiveText: '   ' })).toBe(false)
+  })
+  it('tracks a normal message when effectiveText is provided and non-empty', () => {
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: false, effectiveText: 'draft the email' })).toBe(true)
+  })
+})

package/telegram-plugin/uat/scenarios/jtbd-rapid-followup-dm.test.ts

@@ -55,8 +55,15 @@ describe("uat: rapid follow-ups — steering vs queued classification", () => {
           (m) => {
             const txt = m.text;
             const mentionsMd5 = /\bmd5\b/i.test(txt);
+            // Steer narration: the agent acknowledges amending the in-flight
+            // task. Accept the phrasings the model actually uses — including
+            // "Switched to MD5 per your update/follow-up" (the 2026-06-02
+            // canary reply that the old regex wrongly rejected). Anchored on
+            // "per your <qualifier>" / continuation language so it stays
+            // distinct from the QUEUED path (a fresh answer with no such
+            // course-correction narration).
             const narratesSteer =
-              /↪️|\bsteer(ing)?\b|continuing the (prior|original|in-flight) task|amendment|course[- ]correct/i.test(
+              /↪️|\bsteer(ing)?\b|switch(?:ed|ing)? to \w+ per your (?:update|follow-?up|guidance|request|steer)|continuing the (prior|original|in-flight) task|amendment|course[- ]correct/i.test(
                 txt,
               );
             return mentionsMd5 && narratesSteer;