@ouro.bot/cli 0.1.0-alpha.932 → 0.1.0-alpha.934

package/changelog.json

@@ -1,6 +1,25 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.934",
+      "changes": [
+        "Hold duplicate Teams activities durably before model execution, steering or quoted queuing, preserving receipts across restart and session reset.",
+        "Do not replay uncertain Teams sends after a lost acknowledgement; split-message recovery requires an explicit HTTP 413 and smaller payloads.",
+        "Preserve unconsumed Teams steering in its original request context, reject incomplete production identities, and bypass the SDK stream hidden retry loop with acknowledged single-attempt messages.",
+        "Keep distinct Teams fallback actors separate when optional AAD metadata is empty.",
+        "Include bot and request correlation context on Teams handler and SDK error telemetry."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.933",
+      "changes": [
+        "Recover existing supervised Teams tunnels after permanent rejection or sustained readiness loss, with scoped and confirmed bot endpoint registration.",
+        "Recover accepted Shepherd notice intent without importing audit history, and compact pending observations into bounded historical session digests with durable receipt custody.",
+        "Preserve valid premature judgments independently of invalid suggested replies; keep length-only periodic fixed-text continuation behind all existing input safety guards.",
+        "Correlate Teams request and reply stages without message bodies, and contain notice-ledger failures so later returns remain runnable."
+      ]
+    },
     {
       "version": "0.1.0-alpha.932",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.932",
+  "runtimeVersion": "0.1.0-alpha.934",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-09-03T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>ouro-butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.932</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.934</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/mind/session-transaction.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionTransactionError = exports.SessionTurnBusyError = void 0;
+exports.admitSessionActivity = admitSessionActivity;
 exports.acquireSessionTurnLease = acquireSessionTurnLease;
 exports.withSessionTurnLease = withSessionTurnLease;
 exports.withImmediateSessionTurnLease = withImmediateSessionTurnLease;
@@ -176,21 +177,78 @@ function checkTemporary(pin, filePath, identity) {
 function openLeaseDatabase(lockPath, busyTimeoutMs = 0, confinement = null) {
     checkConfinement(confinement);
     const database = new better_sqlite3_1.default(lockPath);
-    database.pragma(`busy_timeout = ${busyTimeoutMs}`);
-    database.exec(`
-    CREATE TABLE IF NOT EXISTS session_turn_lease (
-      singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-      pid INTEGER NOT NULL,
-      owner_id TEXT NOT NULL,
-      owner_token TEXT NOT NULL
-    )
-  `);
-    const columns = new Set(database.prepare(`PRAGMA table_info(session_turn_lease)`).all().map((column) => column.name));
-    if (!columns.has("boot_identity"))
-        database.exec(`ALTER TABLE session_turn_lease ADD COLUMN boot_identity TEXT`);
-    if (!columns.has("process_started_at"))
-        database.exec(`ALTER TABLE session_turn_lease ADD COLUMN process_started_at TEXT`);
-    return database;
+    try {
+        database.pragma(`busy_timeout = ${busyTimeoutMs}`);
+        database.transaction(() => {
+            database.exec(`
+        CREATE TABLE IF NOT EXISTS session_turn_lease (
+          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+          pid INTEGER NOT NULL,
+          owner_id TEXT NOT NULL,
+          owner_token TEXT NOT NULL
+        )
+      `);
+            const columns = new Set(database.prepare(`PRAGMA table_info(session_turn_lease)`).all().map((column) => column.name));
+            if (!columns.has("boot_identity"))
+                database.exec(`ALTER TABLE session_turn_lease ADD COLUMN boot_identity TEXT`);
+            if (!columns.has("process_started_at"))
+                database.exec(`ALTER TABLE session_turn_lease ADD COLUMN process_started_at TEXT`);
+        }).immediate();
+        return database;
+    }
+    catch (error) {
+        database.close();
+        throw error;
+    }
+}
+/** Immutable admission, not proof of execution or delivery. Unknown effects must never be replayed. */
+function admitSessionActivity(sessionPath, input) {
+    if (typeof input.namespace !== "string" || !input.namespace.trim() || Buffer.byteLength(input.namespace) > 4096
+        || typeof input.activityId !== "string" || !input.activityId.trim() || Buffer.byteLength(input.activityId) > 1024
+        || typeof input.payloadDigest !== "string" || !/^[a-f0-9]{64}$/.test(input.payloadDigest)) {
+        throw new SessionTransactionError("invalid session activity admission");
+    }
+    const canonical = canonicalSessionPath(sessionPath);
+    const lockPath = `${canonical}.turn.lock`;
+    fs.mkdirSync(path.dirname(canonical), { recursive: true, mode: 0o700 });
+    const receiptId = revision(JSON.stringify([input.namespace, input.activityId]));
+    const database = openLeaseDatabase(lockPath, 1000);
+    try {
+        database.pragma("synchronous = FULL");
+        const state = database.transaction(() => {
+            database.exec(`
+        CREATE TABLE IF NOT EXISTS session_activity_receipts (
+          receipt_id TEXT PRIMARY KEY,
+          payload_digest TEXT NOT NULL,
+          admitted_at TEXT NOT NULL
+        )
+      `);
+            const existing = database.prepare("SELECT payload_digest FROM session_activity_receipts WHERE receipt_id = ?")
+                .get(receiptId);
+            if (existing) {
+                if (typeof existing.payload_digest !== "string" || !/^[a-f0-9]{64}$/.test(existing.payload_digest)) {
+                    throw new SessionTransactionError("invalid session activity receipt");
+                }
+                if (existing.payload_digest !== input.payloadDigest)
+                    throw new SessionTransactionError("conflicting session activity payload");
+                return "duplicate";
+            }
+            // Never evict an admission: losing its identity would authorize uncertain work again.
+            if (fs.statSync(lockPath).size >= 64 * 1024 * 1024)
+                throw new SessionTransactionError("session activity receipt capacity exceeded");
+            database.prepare("INSERT INTO session_activity_receipts (receipt_id, payload_digest, admitted_at) VALUES (?, ?, ?)")
+                .run(receiptId, input.payloadDigest, new Date().toISOString());
+            return "admitted";
+        }).immediate();
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind", event: "mind.session_activity_admission", message: "recorded session activity admission decision",
+            meta: { receiptId, state },
+        });
+        return { state, receiptId };
+    }
+    finally {
+        database.close();
+    }
 }
 function acquisitionRecord(options) {
     const pid = options.pid ?? process.pid;

package/dist/senses/shepherd/judge.js

@@ -25,11 +25,11 @@ const CALLBACKS = { onModelStart: NOOP, onModelStreamStart: NOOP, onTextChunk: N
 function replyTextProblem(text) {
     const line = text.replace(/`/g, "").replace(/\s+/g, " ").trim();
     if (!line)
-        return { problem: "an empty reply" };
-    if (line.length > exports.REPLY_MAX_CHARS)
-        return { problem: `a reply of ${line.length} characters (the limit is ${exports.REPLY_MAX_CHARS})` };
+        return { problem: "an empty reply", issue: "missing" };
     if (/[\\@;$|<>&\p{Cc}\p{Cf}]/u.test(line) || /^[/!#]/.test(line))
-        return { problem: "a reply with characters a terminal could read as a command" };
+        return { problem: "a reply with characters a terminal could read as a command", issue: "unsafe" };
+    if (line.length > exports.REPLY_MAX_CHARS)
+        return { problem: `a reply of ${line.length} characters (the limit is ${exports.REPLY_MAX_CHARS})`, issue: "too_long" };
     return { line };
 }
 function safeReplyText(text) {
@@ -81,8 +81,10 @@ function parseVerdict(content) {
             return { kind: "unclear", reply: null, reason: `premature, but the key came from JSON inside prose: ${reason}` };
         return { kind, reply: { key: reply.key }, reason };
     }
-    const checked = typeof reply.text === "string" ? replyTextProblem(reply.text) : { problem: "no reply" };
-    return "line" in checked ? { kind, reply: { text: checked.line }, reason } : { kind: "unclear", reply: null, reason: `premature, but the judge gave ${checked.problem}: ${reason}` };
+    const checked = Object.hasOwn(reply, "key") ? { problem: "an unsupported key", issue: "unsafe" }
+        : typeof reply.text === "string" ? replyTextProblem(reply.text) : { problem: "no reply", issue: "missing" };
+    return "line" in checked ? { kind, reply: { text: checked.line }, reason }
+        : { kind: parsed.inProse ? "unclear" : kind, reply: null, replyIssue: checked.issue, reason: `premature, but the judge gave ${checked.problem}: ${reason}` };
 }
 function judgeMessages(packet) {
     return [

package/dist/senses/shepherd/owner-notice.js

@@ -47,7 +47,6 @@ const friends_1 = require("@ouro.bot/friends");
 const await_alert_1 = require("../../heart/awaiting/await-alert");
 const config_1 = require("../../heart/config");
 const runtime_1 = require("../../nerves/runtime");
-const returns_1 = require("./returns");
 const notice_outbox_1 = require("./notice-outbox");
 /**
  * The owner notice: after a judged return, the agent's owner hears what happened in one short plain message on their
@@ -55,12 +54,23 @@ const notice_outbox_1 = require("./notice-outbox");
  * policy covers whether or not the Ouro agent decides it matters. Returns that arrive close together share one message.
  */
 exports.NOTICE_COALESCE_MS = 5_000;
-/** Returns named one by one in a coalesced message; the rest are counted. */
+/** Distinct sessions named in a digest; the remaining sessions are counted. */
 exports.NOTICE_LIST_MAX = 6;
 exports.NOTICE_RETRY_MS = 30_000;
 const NAME_MAX = 60;
 const REASON_MAX = 300;
 const REPLY_MAX = 240;
+const BLOCK_DESCRIPTION = {
+    reply_invalid: "the suggested reply was invalid",
+    menu_disallowed: "scheduled continuation cannot approve a menu",
+    host_unverified: "the host could not verify safe input state",
+    guidance: "operator guidance blocked input",
+    loop_guard: "the reply limit was reached",
+    focus: "the human owns the focused session",
+    state_changed: "the target state changed",
+    custody: "input delivery was already claimed or needs reconciliation",
+    stopped: "Shepherd stopped",
+};
 /** Kinds a "needs-me" owner still hears about. */
 const NEEDS_ME = new Set(["gate", "done", "loop_guard"]);
 function noticeWanted(policy, record) {
@@ -103,6 +113,8 @@ function noticeLine(record, location) {
                 const sent = record.reply.startsWith("key:") ? `pressed ${plain(record.reply.slice(4), 10)}` : `sent it back: "${plain(record.reply, REPLY_MAX)}"`;
                 return `${subject} stopped early, so I ${sent}. ${why}`;
             }
+            if (record.actionBlockReason)
+                return `${subject} stopped early; no input sent because ${BLOCK_DESCRIPTION[record.actionBlockReason]}. ${why}`;
             return `${subject} stopped early, but I did not answer it, so it is waiting for you. ${why}`;
         case "gate":
             return `${subject} needs you. ${why}`;
@@ -120,13 +132,30 @@ function noticeLine(record, location) {
             return `${subject} stopped but I could not judge it, so I left it. ${why}`;
     }
 }
-/** One message for a burst: a single return is its line; several are a short list, the extra ones counted. */
-function noticeMessage(records, refs = new Map()) {
-    const lines = records.slice(0, exports.NOTICE_LIST_MAX).map((record) => noticeLine(record, refs.get(record.session)));
-    if (records.length === 1)
-        return lines[0];
-    const more = records.length - lines.length;
-    return [`${records.length} coding agents stopped:`, ...lines.map((line) => `- ${line}`), ...(more > 0 ? [`- and ${more} more.`] : [])].join("\n");
+/** A bounded display of latest observations; all input records retain delivery custody. */
+function noticeMessage(records, refs = new Map(), context = {}) {
+    const latest = new Map();
+    for (const record of records) {
+        const key = JSON.stringify([record.host, record.session]);
+        const previous = latest.get(key);
+        const at = Date.parse(record.at);
+        const previousAt = previous ? Date.parse(previous.at) : NaN;
+        if (!previous || (Number.isFinite(at) && (!Number.isFinite(previousAt) || at > previousAt))
+            || ((!Number.isFinite(at) && !Number.isFinite(previousAt) || at === previousAt) && record.transition > previous.transition))
+            latest.set(key, record);
+    }
+    const sessions = [...latest].sort(([a], [b]) => a < b ? -1 : 1).map(([, record]) => record);
+    const lines = sessions.slice(0, exports.NOTICE_LIST_MAX).map(record => {
+        const line = noticeLine(record, refs.get(record.session));
+        if (!context.recovered)
+            return line;
+        const at = Date.parse(record.at);
+        return `${line} (${Number.isFinite(at) ? `observed at ${new Date(at).toISOString()}` : "observation time unknown"})`;
+    });
+    const more = sessions.length - lines.length;
+    const body = sessions.length === 1 ? lines[0]
+        : [`Updates from ${sessions.length} coding sessions:`, ...lines.map(line => `- ${line}`), ...(more > 0 ? [`- and ${more} more.`] : [])].join("\n");
+    return context.recovered ? `Includes recovered historical observations, not live status:\n${body}` : body;
 }
 function teamsAadId(friend) {
     const ext = friend.externalIds.find((entry) => entry.provider === "aad" && !entry.externalId.startsWith("group:"));
@@ -192,30 +221,43 @@ function createTeamsNoticeSender(agentRoot, deps = {}) {
         return sendProactiveTeamsMessageToSession({ friendId: target.friendId, sessionKey: target.key, text, textFormat: "plain", intent: "generic_outreach", captureReceipt: true }, { botApi: await bot, store: new friends_1.FileFriendStore(path.join(agentRoot, "friends")) });
     };
 }
-/** Collects notices for NOTICE_COALESCE_MS after the first, then sends them as one message. It never throws. */
+/** Collects durable notice intents; acceptance is distinct from transport delivery. */
 function createOwnerNotifier(options) {
     const { agent, policy } = options;
     const resolveTargets = options.resolveTargets ?? (() => resolveNoticeTargets(options.agentRoot));
     const send = options.send ?? createTeamsNoticeSender(options.agentRoot);
     const retryWrites = new Map();
+    const recoveredNoticeIds = new Set();
     const writes = new Set();
     let cancel = null;
     let stopped = false;
     let flushing = null;
+    let drainRequested = false;
     function schedule(ms) {
         if (!stopped && policy !== "off")
-            cancel ??= options.schedule(() => { void flush(); }, ms);
+            cancel ??= options.schedule(() => {
+                cancel?.();
+                cancel = null;
+                if (flushing)
+                    drainRequested = true;
+                else
+                    void flush();
+            }, ms);
     }
     function persistIntent(record) {
         const key = `${record.host}:${record.session}:${record.transition}:${record.at}`;
         retryWrites.set(key, record);
-        const write = (0, notice_outbox_1.enqueueNotice)(options.agentRoot, record).then(() => {
+        const write = (0, notice_outbox_1.enqueueNotice)(options.agentRoot, record).then(id => {
             retryWrites.delete(key);
+            return id;
         }).catch(error => {
             (0, runtime_1.emitNervesEvent)({ level: "error", component: "senses", event: "senses.shepherd_notice_error", message: "could not persist a Shepherd owner notice intent; it remains waiting", meta: { agent, error: error.message } });
             schedule(exports.NOTICE_RETRY_MS);
-        }).finally(() => { writes.delete(write); });
+            throw error;
+        });
         writes.add(write);
+        // Observe cleanup immediately, while the producer still receives the rejecting promise.
+        void write.then(() => { writes.delete(write); }, () => { writes.delete(write); });
         return write;
     }
     async function runFlush() {
@@ -223,10 +265,11 @@ function createOwnerNotifier(options) {
         cancel = null;
         if (stopped || policy === "off")
             return;
-        await Promise.all([...writes]);
-        for (const record of [...retryWrites.values()])
-            await persistIntent(record);
         try {
+            await Promise.allSettled([...writes]);
+            const retried = await Promise.allSettled([...retryWrites.values()].map(persistIntent));
+            if (retried.some(result => result.status === "rejected"))
+                schedule(exports.NOTICE_RETRY_MS);
             const entries = (0, notice_outbox_1.readNoticeOutbox)(options.agentRoot).filter(entry => noticeWanted(policy, entry.record) && (Object.keys(entry.deliveries).length === 0 || Object.values(entry.deliveries).some(value => value.state !== "sent")));
             if (entries.length === 0)
                 return;
@@ -239,6 +282,8 @@ function createOwnerNotifier(options) {
                 // Without the host's handles, each notice names a short session id instead.
             }
             const targets = await resolveTargets();
+            if (stopped)
+                return;
             if (targets.length === 0) {
                 (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_notice_no_target", message: "no family friend is reachable on Teams, so the Shepherd owner notice was not sent", meta: { agent, returns: entries.length } });
                 schedule(exports.NOTICE_RETRY_MS);
@@ -248,15 +293,21 @@ function createOwnerNotifier(options) {
             const reachable = new Set(targets.map(target => target.friendId));
             let retry = entries.some(entry => Object.entries(entry.deliveries).some(([friendId, delivery]) => delivery.state === "pending" && !reachable.has(friendId)));
             for (const target of targets) {
+                if (stopped)
+                    break;
                 const pending = entries.filter(entry => (0, notice_outbox_1.noticeDeliveryState)(entry, target.friendId) === "pending");
-                for (let start = 0; start < pending.length && !stopped; start += exports.NOTICE_LIST_MAX) {
+                if (pending.length > 0) {
                     // Only the worker that atomically claims a pending entry may initiate transport.
-                    const batch = await (0, notice_outbox_1.claimPendingNotices)(options.agentRoot, pending.slice(start, start + exports.NOTICE_LIST_MAX).map(entry => entry.id), target.friendId, new Date().toISOString());
+                    const batch = await (0, notice_outbox_1.claimPendingNotices)(options.agentRoot, pending.map(entry => entry.id), target.friendId, new Date().toISOString());
                     if (batch.length === 0)
                         continue;
                     const ids = batch.map(entry => entry.id);
+                    if (stopped) {
+                        await (0, notice_outbox_1.recordNoticeDelivery)(options.agentRoot, ids, target.friendId, { state: "pending", at: new Date().toISOString(), reason: "stopped before transport" });
+                        break;
+                    }
                     try {
-                        const result = await send(target, noticeMessage(batch.map(entry => entry.record), refs));
+                        const result = await send(target, noticeMessage(batch.map(entry => entry.record), refs, { recovered: ids.some(id => recoveredNoticeIds.has(id)) }));
                         const state = result.delivered ? "sent"
                             : result.delivery ? result.delivery.state === "not_sent" ? "pending" : "unknown"
                                 : result.reason && result.reason !== "send_error" ? "pending" : "unknown";
@@ -288,19 +339,20 @@ function createOwnerNotifier(options) {
     function flush() {
         if (flushing)
             return flushing;
-        flushing = runFlush().finally(() => { flushing = null; });
+        flushing = runFlush().finally(() => {
+            flushing = null;
+            if (drainRequested) {
+                drainRequested = false;
+                schedule(exports.NOTICE_COALESCE_MS);
+            }
+        });
         return flushing;
     }
     try {
         const existing = (0, notice_outbox_1.readNoticeOutbox)(options.agentRoot);
-        let recovered = false;
-        for (const record of (0, returns_1.readReturns)(options.agentRoot)) {
-            if (record.noticeEligible === true && noticeWanted(policy, record) && !(0, notice_outbox_1.knownNotice)(options.agentRoot, (0, notice_outbox_1.noticeRecordId)(record), existing)) {
-                void persistIntent(record);
-                recovered = true;
-            }
-        }
-        if (recovered || existing.some(entry => Object.keys(entry.deliveries).length === 0 || Object.values(entry.deliveries).some(value => value.state === "pending")))
+        for (const entry of existing)
+            recoveredNoticeIds.add(entry.id);
+        if (existing.some(entry => Object.keys(entry.deliveries).length === 0 || Object.values(entry.deliveries).some(value => value.state === "pending")))
             schedule(exports.NOTICE_RETRY_MS);
     }
     catch (error) {
@@ -309,11 +361,13 @@ function createOwnerNotifier(options) {
     }
     return {
         notify(record) {
-            if (stopped || !noticeWanted(policy, record))
-                return Promise.resolve();
+            if (stopped)
+                return Promise.resolve({ state: "suppressed", reason: "stopped" });
+            if (!noticeWanted(policy, record))
+                return Promise.resolve({ state: "suppressed", reason: "policy" });
             const write = persistIntent(record);
             schedule(exports.NOTICE_COALESCE_MS);
-            return write;
+            return write.then(noticeId => ({ state: "queued", noticeId }));
         },
         flush,
         stop() {

package/dist/senses/shepherd/sense.js

@@ -368,6 +368,7 @@ async function startShepherdSenseApp(options) {
             guidanceRevision: String(record.guidanceRevision), reply: "key" in reply ? `key:${reply.key}` : reply.text,
             trigger: record.trigger, transition: record.transition, at: record.at }, dispatchOwner);
         if (!claim) {
+            record.actionBlockReason = "custody";
             record.reason = `durable dispatch custody refused duplicate or unresolved input: ${record.reason}`;
             return false;
         }
@@ -385,6 +386,7 @@ async function startShepherdSenseApp(options) {
             }
         }
         catch (error) {
+            record.actionBlockReason = "custody";
             record.dispatch.state = "unknown";
             try {
                 custody.completeDispatch(claim.id, dispatchOwner, { state: "unknown", reason: field((0, redact_1.redactSecrets)(String(error)), 200) });
@@ -399,6 +401,7 @@ async function startShepherdSenseApp(options) {
             ...(result.reason ? { reason: field((0, redact_1.redactSecrets)(result.reason), 200) } : {}) });
         record.dispatch.state = result.state;
         if (result.state === "not_sent") {
+            record.actionBlockReason = "state_changed";
             record.reason = `guarded host refused before input: ${result.reason ?? "target changed"}; ${record.reason}`;
             return false;
         }
@@ -420,18 +423,26 @@ async function startShepherdSenseApp(options) {
         /** False for a return nothing new was decided about: the loop guard still holds, or the same background wait. */
         let notice = true;
         let noticeSignature = null;
+        let observationSignature = null;
+        let noticeBasis = null;
+        let status = null;
+        let quietWorkingStatus = false;
+        let escalateOutcome = false;
+        let wakeOutcome = false;
         let judged = false;
         try {
             let current;
             if (periodic) {
                 notice = false;
                 if (periodic.generation !== generationFor(event.sessionId) || now() - periodic.observedAt < cmux_1.QUIET_MS) {
+                    record.actionBlockReason = "state_changed";
                     record.reason = "the check-in observation was invalidated or has not been quiet long enough";
                     return;
                 }
                 current = await host.inspect(event.sessionId);
                 if (stopped || periodic.generation !== generationFor(event.sessionId) ||
                     inspectionFingerprint(current) !== inspectionFingerprint(periodic.first) || current.session.focused) {
+                    record.actionBlockReason = stopped ? "stopped" : current.session.focused ? "focus" : "state_changed";
                     record.reason = "the check-in target changed during the quiet interval";
                     return;
                 }
@@ -440,6 +451,7 @@ async function startShepherdSenseApp(options) {
             if (state.tripped) {
                 // Tripped: no judge call and no new escalation until the human looks at the session.
                 Object.assign(record, { kind: "loop_guard", reason: `Shepherd stopped answering this session until ${human} focuses it` });
+                record.actionBlockReason = "loop_guard";
                 notice = false;
                 return;
             }
@@ -456,11 +468,21 @@ async function startShepherdSenseApp(options) {
             record.task = [...text.matchAll(/Desk-Task:\s*(\S+)/g)].pop()?.[1] ?? null;
             const screen = (0, redact_1.screenTail)(text, exports.SCREEN_LINES);
             if (recovery && screen !== recovery.screen) {
+                record.actionBlockReason = "state_changed";
                 record.reason = "the screen changed since the network stop, so recovery was not sent";
                 return;
             }
             const target = { host: host.name, session: event.sessionId, cwd: record.cwd, task: record.task };
-            const guidance = guidanceFor(target);
+            const checkedGuidance = () => {
+                try {
+                    return guidanceFor(target);
+                }
+                catch (error) {
+                    record.actionBlockReason = "guidance";
+                    throw error;
+                }
+            };
+            const guidance = checkedGuidance();
             record.guidanceRevision = guidance.revision;
             let verdict;
             try {
@@ -478,117 +500,172 @@ async function startShepherdSenseApp(options) {
             }
             judged = true;
             if (periodic && (stopped || periodic.generation !== generationFor(event.sessionId))) {
+                record.actionBlockReason = stopped ? "stopped" : "state_changed";
                 record.reason = "the check-in was invalidated during judgment; no input or notice sent";
                 return;
             }
             // The host's own word that background work is running outranks a reading of the screen: such a stop is never a return.
             const kind = (current ? current.backgroundWork : event.backgroundWork) ? "working" : verdict.kind;
             const news = verdict.news === true || (kind === "working" && verdict.kind === "gate");
-            Object.assign(record, { kind, reason: verdict.reason, latencyMs: verdict.latencyMs, inputTokens: verdict.inputTokens });
+            Object.assign(record, { kind, judgeKind: verdict.kind, reason: verdict.reason, latencyMs: verdict.latencyMs, inputTokens: verdict.inputTokens,
+                ...(verdict.replyIssue ? { replyIssue: verdict.replyIssue } : {}) });
             if (!recovery && !periodic && kind === "waiting" && verdict.waitingOnNetwork)
                 rememberNetworkWait(event, screen);
-            noticeSignature = fingerprint([host.name, event.sessionId, record.agent, record.cwd, record.task, screen, guidance.revision, kind]);
-            notice = !periodic || custody.shouldNotify(noticeSignature);
+            const noticeScreen = screen.replace(/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})\b/g, "<observation-time>");
+            noticeBasis = [host.name, event.sessionId, record.agent, record.cwd, record.task, noticeScreen, guidance.revision];
+            notice = true;
             // A terminal that keeps going quiet without needing anything is checked less often.
             if (!periodic)
                 host.pace?.(event.sessionId, kind === "working" || kind === "unclear");
             state.answers = state.answers.filter((at) => now() - at < 3_600_000);
             if (kind === "working") {
                 // Still working: a progress update, never an answer. It reaches the Ouro agent only when it carries news, and wakes nothing.
-                if (news && notice)
-                    escalate(escalationContent(record, human));
+                if (news)
+                    escalateOutcome = true;
                 else
                     notice = false;
-                if (!periodic || notice)
-                    await host.signal(event.sessionId, field(`${record.agent ?? "agent"} waiting on its background work: ${verdict.reason}`, 120));
+                quietWorkingStatus = !periodic && !news;
+                status = `${record.agent ?? "agent"} waiting on its background work: ${verdict.reason}`;
             }
-            if (kind === "premature" && verdict.reply) {
-                if ((recovery || periodic) && "key" in verdict.reply) {
+            const actionableReply = verdict.reply ?? (periodic && verdict.replyIssue === "too_long" ? { text: exports.PERIODIC_RESUME } : null);
+            if (kind === "premature" && !actionableReply)
+                record.actionBlockReason = "reply_invalid";
+            if (kind === "premature" && actionableReply) {
+                if ((recovery || periodic) && "key" in actionableReply) {
+                    record.actionBlockReason = "menu_disallowed";
                     record.reason = `${periodic ? "periodic check-in" : "connectivity recovery"} never presses approval or menu keys: ${verdict.reason}`;
                 }
                 else if (periodic && (!current.instance || current.activity !== "idle" || current.composer !== "empty" ||
                     current.backgroundWork !== false || !current.session.agent || !host.promptIfUnchanged)) {
+                    record.actionBlockReason = "host_unverified";
                     record.reason = `the host cannot verify an idle, empty, supported agent process for guarded input: ${verdict.reason}`;
                 }
                 else if (guidance.paused) {
+                    record.actionBlockReason = "guidance";
                     record.reason = `Shepherd guidance has this session paused, so nothing was sent: ${verdict.reason}`;
                 }
                 else if (state.streak >= exports.STREAK_MAX || state.answers.length >= exports.HOURLY_MAX) {
                     Object.assign(record, { kind: "loop_guard", reason: `loop guard: ${verdict.reason}` });
+                    record.actionBlockReason = "loop_guard";
                     state.tripped = true;
                 }
                 else {
                     const sessions = await host.list();
                     const session = sessions.find(session => session.id === event.sessionId);
                     if (now() - state.focusedAt < exports.FOCUS_HOLD_MS || session?.focused) {
+                        record.actionBlockReason = "focus";
                         // Never type into the session the human is in, or one they just left.
                         record.reason = `${human} is in this session or just left it, so it is theirs: ${verdict.reason}`;
                     }
                     else if (periodic && (!session || session.agent !== current.session.agent || session.cwd !== current.session.cwd)) {
+                        record.actionBlockReason = "state_changed";
                         record.reason = `the check-in target changed while judging, so nothing was sent: ${verdict.reason}`;
                     }
                     else if (!periodic && (0, redact_1.withoutNumbers)((0, redact_1.screenTail)((0, redact_1.redactSecrets)(await host.read(event.sessionId, exports.READ_LINES)), exports.SCREEN_LINES)) !== (0, redact_1.withoutNumbers)(screen)) {
+                        record.actionBlockReason = "state_changed";
                         record.reason = `the screen changed while judging, so nothing was sent: ${verdict.reason}`;
                     }
                     else {
                         const finalInspection = periodic ? await host.inspect(event.sessionId) : undefined;
                         if (periodic && (stopped || periodic.generation !== generationFor(event.sessionId) ||
                             finalInspection.session.focused || inspectionFingerprint(finalInspection) !== inspectionFingerprint(current))) {
+                            record.actionBlockReason = stopped ? "stopped" : finalInspection.session.focused ? "focus" : "state_changed";
                             record.reason = `the check-in changed while judging, so nothing was sent: ${verdict.reason}`;
                             return;
                         }
                         // No awaited host reads between this final check and initiating the send.
-                        const latest = guidanceFor(target);
+                        const latest = checkedGuidance();
                         if (stopped || (recovery && (latestReturns.get(event.sessionId) !== event || now() - state.focusedAt < exports.FOCUS_HOLD_MS)) ||
                             periodic && (periodic.generation !== generationFor(event.sessionId) || now() - state.focusedAt < exports.FOCUS_HOLD_MS)) {
+                            record.actionBlockReason = stopped ? "stopped" : now() - state.focusedAt < exports.FOCUS_HOLD_MS ? "focus" : "state_changed";
                             record.reason = `Shepherd stopped, the human focused this session, or it returned again while judging, so nothing was sent: ${verdict.reason}`;
                         }
                         else if (latest.paused || latest.revision !== guidance.revision) {
+                            record.actionBlockReason = "guidance";
                             record.reason = `Shepherd guidance paused or changed while judging (revision ${guidance.revision} to ${latest.revision}), so nothing was sent: ${verdict.reason}`;
                         }
                         else {
-                            const reply = periodic ? { text: exports.PERIODIC_RESUME } : recovery ? { text: NETWORK_RESUME } : verdict.reply;
+                            const reply = periodic ? { text: exports.PERIODIC_RESUME } : recovery ? { text: NETWORK_RESUME } : actionableReply;
                             const canSend = periodic ? () => {
                                 if (stopped || periodic.generation !== generationFor(event.sessionId) || now() - state.focusedAt < exports.FOCUS_HOLD_MS)
                                     return false;
-                                const live = guidanceFor(target);
+                                const live = checkedGuidance();
                                 return !live.paused && live.revision === guidance.revision;
                             } : undefined;
                             if (await dispatch(record, reply, current?.instance ?? session?.instance ?? null, fingerprint(screen), periodic ? current : undefined, canSend)) {
                                 Object.assign(record, { action: "respond", reply: "key" in reply ? `key:${reply.key}` : reply.text });
                                 state.streak += 1;
                                 state.answers.push(now());
-                                if (!periodic || notice)
-                                    await host.signal(event.sessionId, field(`answered for ${human}: ${verdict.reason}`, 120));
+                                status = `answered for ${human}: ${verdict.reason}`;
                             }
                         }
                     }
                 }
             }
-            if ((!periodic || notice) && (record.kind === "gate" || record.kind === "done" || record.kind === "waiting" || record.kind === "loop_guard")) {
-                escalate(escalationContent(record, human));
-                requestWake(record.transition);
-                await host.signal(event.sessionId, field(`${record.kind === "gate" ? `needs ${human}` : record.kind === "done" ? "done" : record.kind === "waiting" ? "waiting on an outside dependency" : "stopped answering"}: ${verdict.reason}`, 120));
+            if (record.kind === "gate" || record.kind === "done" || record.kind === "waiting" || record.kind === "loop_guard") {
+                escalateOutcome = true;
+                wakeOutcome = true;
+                status = `${record.kind === "gate" ? `needs ${human}` : record.kind === "done" ? "done" : record.kind === "waiting" ? "waiting on an outside dependency" : "stopped answering"}: ${verdict.reason}`;
             }
         }
         catch (error) {
             Object.assign(record, { kind: record.reason ? record.kind : "error", reason: `${record.reason ? `${record.reason}; then ` : ""}${error.message}` });
         }
         finally {
+            if (noticeBasis && notice) {
+                observationSignature = fingerprint([...noticeBasis, record.kind, record.actionBlockReason === "custody" ? null : record.actionBlockReason ?? null]);
+                noticeSignature = record.action === "respond" ? fingerprint([observationSignature, "respond", record.reply])
+                    : record.dispatch?.state === "unknown" ? fingerprint([observationSignature, "unknown"]) : observationSignature;
+                try {
+                    notice = custody.shouldNotify(noticeSignature);
+                }
+                catch (error) {
+                    notice = false;
+                    record.noticeState = "failed";
+                    (0, runtime_1.emitNervesEvent)({ level: "error", component: "senses", event: "senses.shepherd_notice_error", message: "could not compare owner-notice suppression; no new delivery intent accepted", meta: { agent, reason: "signature_read_failed", error: error.message } });
+                }
+            }
+            try {
+                if (notice && escalateOutcome) {
+                    escalate(escalationContent(record, human));
+                    if (wakeOutcome)
+                        requestWake(record.transition);
+                }
+                if (status && (notice || quietWorkingStatus))
+                    await host.signal(event.sessionId, field(status, 120));
+            }
+            catch (error) {
+                record.reason += `; outcome signaling failed: ${error.message}`;
+            }
             record.noticeEligible = notice;
-            log(record);
-            if (judged || !periodic)
-                history.set(event.sessionId, record);
             if (notice) {
                 try {
-                    await notifyOwner(record);
-                    if (noticeSignature)
-                        custody.markNotified(noticeSignature, record.at);
+                    const acceptance = await notifyOwner(record);
+                    record.noticeState = acceptance.state;
+                    if (acceptance.state === "queued")
+                        record.noticeId = acceptance.noticeId;
+                    else
+                        record.noticeSuppressionReason = acceptance.reason;
+                    if (noticeSignature && (acceptance.state === "queued" || acceptance.reason === "policy")) {
+                        try {
+                            custody.markNotified(noticeSignature, record.at);
+                            // A sent/uncertain effect also settles the unchanged observation, not just that action outcome.
+                            if (observationSignature && observationSignature !== noticeSignature)
+                                custody.markNotified(observationSignature, record.at);
+                        }
+                        catch (error) {
+                            (0, runtime_1.emitNervesEvent)({ level: "error", component: "senses", event: "senses.shepherd_notice_error", message: "owner notice was accepted but its suppression signature could not be recorded", meta: { agent, error: error.message } });
+                        }
+                    }
                 }
                 catch (error) {
-                    (0, runtime_1.emitNervesEvent)({ level: "error", component: "senses", event: "senses.shepherd_notice_error", message: "owner notice custody failed; the eligible return remains logged for recovery", meta: { agent, error: error.message } });
+                    record.noticeState = "failed";
+                    (0, runtime_1.emitNervesEvent)({ level: "error", component: "senses", event: "senses.shepherd_notice_error", message: "owner notice custody failed; the observation is not accepted delivery intent", meta: { agent, error: error.message } });
                 }
             }
+            log(record);
+            if (judged || !periodic)
+                history.set(event.sessionId, record);
         }
     }
     function guidanceFor(target) {

package/dist/senses/teams.js

@@ -72,6 +72,7 @@ const tool_activity_callbacks_1 = require("../heart/tool-activity-callbacks");
 const commands_2 = require("./commands");
 const http = __importStar(require("http"));
 const path = __importStar(require("path"));
+const node_crypto_1 = require("node:crypto");
 const trust_gate_1 = require("./trust-gate");
 const pipeline_1 = require("./pipeline");
 const session_transaction_1 = require("../mind/session-transaction");
@@ -195,6 +196,11 @@ function buildWelcomeCard() {
 // safeSend (ctx.send). Tool results, kicks, and errors use safeUpdate
 // (transient status) or safeSend (terminal errors). Reasoning is accumulated
 // and periodically pushed via safeUpdate on the same flush timer tick.
+function isTeamsSizeRejection(error) {
+    return typeof error === "object" && error !== null && "response" in error
+        && typeof error.response === "object" && error.response !== null && "status" in error.response
+        && error.response.status === 413;
+}
 function createTeamsCallbacks(stream, controller, sendMessage, options) {
     const MIN_INITIAL_CHARS = 20;
     let stopped = false; // set when stream signals cancellation (403)
@@ -298,18 +304,22 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         /* v8 ignore next -- defensive guard: stopped set by prior error; tested via flush abort path @preserve */
         if (stopped)
             return false;
+        let awaitingTransport = false;
         try {
             // stream.emit() is typed as void but the Teams SDK returns a Promise
             // internally (async HTTP). Cast to capture the result for awaiting.
             const result = stream.emit(streamChunk(text));
             streamHasContent = true;
             if (result && typeof result.then === "function") {
+                awaitingTransport = true;
                 await result;
             }
             return true;
         }
         catch (err) {
             markStopped("tryEmit", err);
+            if (awaitingTransport && !isTeamsSizeRejection(err))
+                throw err;
             return false;
         }
     }
@@ -321,15 +331,21 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
     // which has a sendMessage fallback that may still succeed. Caller (flushNow) is
     // responsible for the `!stopped` precondition; no defensive guard here.
     async function tryEmitNoAbort(text) {
+        let awaitingTransport = false;
         try {
             const result = stream.emit(streamChunk(text));
             streamHasContent = true;
             if (result && typeof result.then === "function") {
+                awaitingTransport = true;
                 await result;
             }
             return true;
         }
-        catch {
+        catch (error) {
+            if (awaitingTransport && !isTeamsSizeRejection(error)) {
+                markStopped("speak-unknown", error);
+                throw error;
+            }
             return false;
         }
     }
@@ -606,7 +622,10 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
                     try {
                         await sendMessage(text);
                     }
-                    catch {
+                    catch (error) {
+                        // A lost acknowledgement is not a rejection. Only a definite size rejection permits a smaller retry.
+                        if (!isTeamsSizeRejection(error) || text.length <= RECOVERY_CHUNK_SIZE)
+                            throw error;
                         const chunks = splitMessage(text, RECOVERY_CHUNK_SIZE);
                         for (const chunk of chunks)
                             await sendMessage(chunk);
@@ -636,19 +655,34 @@ const _turnCoordinator = (0, turn_coordinator_1.createTurnCoordinator)();
 function teamsTurnKey(conversationId) {
     return `teams:${conversationId}`;
 }
+function teamsAdmissionKey(conversationId) {
+    return `teams-admission:${conversationId}`;
+}
 const queuedTeamsTurns = new Map();
 const activeTeamsActors = new Map();
+const consumingTeamsSteering = new Set();
+function drainTeamsSteering(key) {
+    const followUps = _turnCoordinator.drainFollowUps(key);
+    const consumed = new Set(followUps);
+    const queue = queuedTeamsTurns.get(key);
+    if (queue)
+        queuedTeamsTurns.set(key, queue.filter(turn => !turn.steering || !consumed.has(turn.steering)));
+    return followUps;
+}
 /** Context-bearing replies cannot steer an already-running tool loop. Keep the
  * original SDK context/transport alive until a fresh handleTeamsMessage lease.
  * Ordinary same-actor steering still uses the existing coordinator buffer. */
 async function coordinateTeamsTurn(conversationId, text, identity, run) {
     const key = teamsTurnKey(conversationId);
-    const actorKey = JSON.stringify([identity.aadObjectId ?? identity.userId ?? "", identity.tenantId ?? ""]);
+    const actorKey = JSON.stringify([identity.aadObjectId || identity.userId || "", identity.tenantId ?? ""]);
     if (!_turnCoordinator.tryBeginTurn(key)) {
-        if (!identity.replyToId && !/\bfeedback:/i.test(text) &&
-            activeTeamsActors.get(key) === actorKey && !queuedTeamsTurns.get(key)?.length) {
-            _turnCoordinator.enqueueFollowUp(key, { conversationId, text, receivedAt: Date.now(),
-                effect: (0, continuity_1.classifySteeringFollowUpEffect)(text) });
+        if (!identity.replyToId && !/\bfeedback:/i.test(text) && consumingTeamsSteering.has(key) &&
+            activeTeamsActors.get(key) === actorKey && !queuedTeamsTurns.get(key)?.some(turn => !turn.steering)) {
+            const steering = { conversationId, text, receivedAt: Date.now(), effect: (0, continuity_1.classifySteeringFollowUpEffect)(text) };
+            _turnCoordinator.enqueueFollowUp(key, steering);
+            const queue = queuedTeamsTurns.get(key) ?? [];
+            queue.push({ actorKey, run, steering, resolve: () => { }, reject: () => { } });
+            queuedTeamsTurns.set(key, queue);
             return;
         }
         await new Promise((resolve, reject) => {
@@ -664,6 +698,12 @@ async function coordinateTeamsTurn(conversationId, text, identity, run) {
     try {
         while (next) {
             activeTeamsActors.set(key, next.actorKey);
+            if (next.steering) {
+                for (const followUp of _turnCoordinator.drainFollowUps(key)) {
+                    if (followUp !== next.steering)
+                        _turnCoordinator.enqueueFollowUp(key, followUp);
+                }
+            }
             try {
                 await next.run();
                 next.resolve();
@@ -674,6 +714,8 @@ async function coordinateTeamsTurn(conversationId, text, identity, run) {
                 next.reject(error);
             }
             first = false;
+            // Preserve received order while identity/admission I/O finishes, without holding admission through a model turn.
+            await _turnCoordinator.withTurnLock(teamsAdmissionKey(conversationId), async () => { });
             next = queuedTeamsTurns.get(key)?.shift();
         }
     }
@@ -694,6 +736,14 @@ function getFriendStore() {
     const friendsPath = path.join((0, identity_1.getAgentRoot)(), "friends");
     return new friends_1.FileFriendStore(friendsPath);
 }
+function reportTeamsRequest(stage, conversationId, context, details = {}) {
+    if (!context?.inboundActivityId)
+        return;
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels", event: "channel.teams_request_stage", message: "Teams conversational request stage",
+        meta: { stage, inboundActivityId: context.inboundActivityId, conversationId, tenantId: context.tenantId, botId: context.botApi?.id, ...details },
+    });
+}
 function createTeamsCommandRegistry() {
     const registry = (0, commands_1.createCommandRegistry)();
     (0, commands_1.registerDefaultCommands)(registry);
@@ -750,14 +800,24 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
     // ── Teams adapter concerns: controller, callbacks, session path ──────────
     const controller = new AbortController();
     const channelConfig = (0, config_2.getTeamsChannelConfig)();
-    const callbacks = createTeamsCallbacks(stream, controller, sendMessage, { conversationId, flushIntervalMs: channelConfig.flushIntervalMs, ...(reactionOverrides?.suppressEmptyStreamMessage ? { suppressEmptyStreamMessage: true } : {}) });
     const traceId = (0, nerves_1.createTraceId)();
+    const observedStream = {
+        emit(activity) {
+            const result = stream.emit(activity);
+            reportTeamsRequest("reply_emitted", conversationId, teamsContext, { traceId, delivery: "unconfirmed_stream" });
+            return result;
+        },
+        update(text) { return stream.update(text); },
+        close: stream.close.bind(stream),
+    };
+    const callbacks = createTeamsCallbacks(observedStream, controller, sendMessage, { conversationId, flushIntervalMs: channelConfig.flushIntervalMs, ...(reactionOverrides?.suppressEmptyStreamMessage ? { suppressEmptyStreamMessage: true } : {}) });
     const sessPath = (0, config_2.sessionPath)(friendId, "teams", conversationId);
     const teamsCapabilities = (0, friends_1.getChannelCapabilities)("teams");
     const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, "teams", conversationId);
     const runWithLease = runtimeOverrides?._withSessionTurnLease ?? session_transaction_1.withSessionTurnLease;
     try {
         await runWithLease(sessPath, async (sessionTurnLease) => {
+            reportTeamsRequest("running", conversationId, teamsContext, { traceId, friendId });
             // Proactive feedback acknowledgements are not magically in this model session's
             // history. Recover their frozen packet only after identity and lease ownership.
             let feedbackReply;
@@ -768,7 +828,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
             catch (error) {
                 if (!(error instanceof feedback_reply_1.FeedbackReplyRefusal))
                     throw error;
-                stream.emit(error.message);
+                await stream.emit(error.message);
                 return;
             }
             // Do not emit any activity until this turn owns the durable session.
@@ -800,7 +860,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                     },
                     mcpManager,
                     drainSteeringFollowUps: () => {
-                        drainedSteeringFollowUps = _turnCoordinator.drainFollowUps(turnKey)
+                        drainedSteeringFollowUps = drainTeamsSteering(turnKey)
                             .map(({ text: followUpText, effect }) => ({ text: followUpText, effect }));
                         return drainedSteeringFollowUps;
                     },
@@ -863,16 +923,24 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                     enforceTrustGate: trust_gate_1.enforceTrustGate,
                     drainPending: pending_1.drainPending,
                     drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(agentName, deferredFriendId),
-                    runAgent: (msgs, cb, channel, sig, opts) => (0, core_1.runAgent)(msgs, cb, channel, sig, {
-                        ...opts,
-                        toolContext: {
-                            /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
-                            signin: async () => undefined,
-                            ...opts?.toolContext,
-                            ...owner,
-                            summarize: teamsToolContext.summarize,
-                        },
-                    }),
+                    runAgent: async (msgs, cb, channel, sig, opts) => {
+                        consumingTeamsSteering.add(turnKey);
+                        try {
+                            return await (0, core_1.runAgent)(msgs, cb, channel, sig, {
+                                ...opts,
+                                toolContext: {
+                                    /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
+                                    signin: async () => undefined,
+                                    ...opts?.toolContext,
+                                    ...owner,
+                                    summarize: teamsToolContext.summarize,
+                                },
+                            });
+                        }
+                        finally {
+                            consumingTeamsSteering.delete(turnKey);
+                        }
+                    },
                     postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
                         const prepared = (0, context_1.postTurnTrim)(turnMessages, usage, hooks);
                         return (0, context_1.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
@@ -898,7 +966,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                 if (result.turnOutcome === "command") {
                     if (result.commandAction === "new") {
                         (0, context_1.deleteSession)(sessPath);
-                        stream.emit("session cleared");
+                        await stream.emit("session cleared");
                     }
                     // For "response" commands: pipeline already emitted the response via onTextChunk
                     await callbacks.flush();
@@ -906,7 +974,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                 }
                 /* v8 ignore start -- failover display: tested via pipeline integration tests @preserve */
                 if (result.failoverMessage) {
-                    stream.emit(result.failoverMessage);
+                    await stream.emit(result.failoverMessage);
                 }
                 else if (capturedTerminalError) {
                     callbacks.onError(capturedTerminalError, "terminal");
@@ -915,7 +983,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                 // ── Handle gate result ────────────────────────────────────────
                 if (!result.gateResult.allowed) {
                     if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
-                        stream.emit(result.gateResult.autoReply);
+                        await stream.emit(result.gateResult.autoReply);
                     }
                     return;
                 }
@@ -962,9 +1030,11 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
     }
     catch (error) {
         if (error instanceof session_transaction_1.SessionTurnBusyError || (error instanceof Error && error.name === "SessionTurnBusyError")) {
-            stream.emit("this conversation is busy finishing another turn; please try again");
+            reportTeamsRequest("failed", conversationId, teamsContext, { traceId, reason: "lease_busy" });
+            await stream.emit("this conversation is busy finishing another turn; please try again");
             return;
         }
+        reportTeamsRequest("failed", conversationId, teamsContext, { traceId, reason: "turn_failed" });
         throw error;
     }
 }
@@ -1153,121 +1223,182 @@ function registerBotHandlers(app, label) {
     });
     /* v8 ignore stop */
     app.on("message", async (ctx) => {
-        const { stream, activity, api, signin } = ctx;
+        const { activity, api, signin } = ctx;
         const text = activity.text || "";
         const convId = activity.conversation?.id || "unknown";
         const turnKey = teamsTurnKey(convId);
         const userId = activity.from?.id || "";
         const channelId = activity.channelId || "msteams";
-        (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.message_received", component: "channels", message: `[${label}] incoming teams message`, meta: { userId: userId.slice(0, 12), conversationId: convId.slice(0, 20) } });
-        const commandRegistry = createTeamsCommandRegistry();
-        const parsedSlashCommand = (0, commands_1.parseSlashCommand)(text);
-        if (parsedSlashCommand) {
-            const dispatchResult = commandRegistry.dispatch(parsedSlashCommand.command, { channel: "teams" });
-            if (dispatchResult.handled && dispatchResult.result) {
-                if (dispatchResult.result.action === "response") {
-                    stream.emit(dispatchResult.result.message || "");
-                    return;
+        const requestContext = {
+            inboundActivityId: activity.id, tenantId: activity.conversation?.tenantId,
+            botApi: app.id && api ? { id: app.id, conversations: api.conversations } : undefined,
+        };
+        const sendText = async (text) => {
+            try {
+                const receipt = await ctx.send({ type: "message", text, replyToId: activity.id, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
+                const messageId = receipt && typeof receipt === "object" && "id" in receipt && typeof receipt.id === "string" ? receipt.id : undefined;
+                reportTeamsRequest(messageId ? "replied" : "reply_emitted", convId, requestContext, { delivery: messageId ? "accepted" : "unconfirmed", ...(messageId ? { outboundActivityId: messageId } : {}) });
+            }
+            catch (error) {
+                reportTeamsRequest("failed", convId, requestContext, { reason: "send_unknown" });
+                throw error;
+            }
+        };
+        // HttpStream queues void emits and retries unknown HTTP failures internally.
+        // Use the SDK's single-attempt, awaitable send instead of that hidden retry loop.
+        const stream = {
+            emit: value => sendText(typeof value === "string" ? value : value.text),
+            update: () => ctx.send({ type: "typing" }),
+            close: async () => undefined,
+        };
+        (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.message_received", component: "channels", message: `[${label}] incoming teams message`, meta: { stage: "received", inboundActivityId: activity.id, botId: app.id, tenantId: requestContext.tenantId, userId: userId.slice(0, 12), conversationId: convId } });
+        let work;
+        await _turnCoordinator.withTurnLock(teamsAdmissionKey(convId), async () => {
+            try {
+                if (process.env.OURO_TEAMS_DEVTOOLS !== "1" && [
+                    app.id, activity.id, activity.channelId, activity.conversation?.id,
+                    activity.conversation?.tenantId, activity.from?.aadObjectId || activity.from?.id,
+                ].some(value => typeof value !== "string" || !value.trim())) {
+                    throw new session_transaction_1.SessionTransactionError("Teams activity identity is incomplete");
                 }
-                if (dispatchResult.result.action === "new") {
-                    const commandStore = getFriendStore();
-                    const commandProvider = activity.from?.aadObjectId ? "aad" : "teams-conversation";
-                    const commandExternalId = activity.from?.aadObjectId || convId;
-                    const commandResolver = new friends_1.FriendResolver(commandStore, {
-                        provider: commandProvider,
-                        externalId: commandExternalId,
+                if (activity.id) {
+                    const store = getFriendStore();
+                    const identity = await new friends_1.FriendResolver(store, {
+                        provider: activity.from?.aadObjectId ? "aad" : "teams-conversation",
+                        externalId: activity.from?.aadObjectId || convId,
                         tenantId: activity.conversation?.tenantId,
                         displayName: activity.from?.name || "Unknown",
                         channel: "teams",
+                    }).resolve();
+                    const admission = (0, session_transaction_1.admitSessionActivity)((0, config_2.sessionPath)(identity.friend.id, "teams", convId), {
+                        namespace: JSON.stringify(["teams.message", channelId, app.id?.toLowerCase() ?? null,
+                            activity.conversation?.tenantId?.toLowerCase() ?? null,
+                            activity.from?.aadObjectId?.toLowerCase() || userId, convId]),
+                        activityId: activity.id,
+                        payloadDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify([text, activity.replyToId ?? null])).digest("hex"),
                     });
-                    const commandContext = await commandResolver.resolve();
-                    (0, context_1.deleteSession)((0, config_2.sessionPath)(commandContext.friend.id, "teams", convId));
-                    stream.emit("session cleared");
-                    if (_turnCoordinator.isTurnActive(turnKey)) {
-                        _turnCoordinator.enqueueFollowUp(turnKey, {
-                            conversationId: convId,
-                            text,
-                            receivedAt: Date.now(),
-                            effect: "clear_and_supersede",
-                        });
+                    if (admission.state === "duplicate") {
+                        reportTeamsRequest("duplicate_held", convId, requestContext, { receiptId: admission.receiptId, outcome: "not_replayed" });
+                        return;
                     }
-                    return;
                 }
+                reportTeamsRequest("admitted", convId, requestContext);
             }
-        }
-        await coordinateTeamsTurn(convId, text, {
-            aadObjectId: activity.from?.aadObjectId, userId, tenantId: activity.conversation?.tenantId,
-            replyToId: activity.replyToId,
-        }, async () => {
-            try {
-                // Resolve OAuth connection names for this user's tenant (supports per-tenant overrides).
-                const tenantId = activity.conversation?.tenantId;
-                const tenantOAuth = (0, config_1.resolveOAuthForTenant)(tenantId);
-                // Fetch tokens for both OAuth connections independently.
-                // Failures are silently caught -- the tool handler will request signin if needed.
-                let graphToken;
-                let adoToken;
-                let githubToken;
-                try {
-                    const graphRes = await api.users.token.get({ userId, connectionName: tenantOAuth.graphConnectionName, channelId });
-                    graphToken = graphRes?.token;
+            catch (error) {
+                reportTeamsRequest("failed", convId, requestContext, { reason: "activity_admission_failed" });
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error", component: "channels", event: "channel.activity_admission_error",
+                    message: "Teams activity was not safely admitted; no new turn or steering was started",
+                    meta: { conversationId: convId, inboundActivityId: activity.id, reason: "activity_admission_failed" },
+                });
+                throw error;
+            }
+            const commandRegistry = createTeamsCommandRegistry();
+            const parsedSlashCommand = (0, commands_1.parseSlashCommand)(text);
+            if (parsedSlashCommand) {
+                const dispatchResult = commandRegistry.dispatch(parsedSlashCommand.command, { channel: "teams" });
+                if (dispatchResult.handled && dispatchResult.result) {
+                    if (dispatchResult.result.action === "response") {
+                        await stream.emit(dispatchResult.result.message || "");
+                        return;
+                    }
+                    if (dispatchResult.result.action === "new") {
+                        const commandStore = getFriendStore();
+                        const commandProvider = activity.from?.aadObjectId ? "aad" : "teams-conversation";
+                        const commandExternalId = activity.from?.aadObjectId || convId;
+                        const commandResolver = new friends_1.FriendResolver(commandStore, {
+                            provider: commandProvider,
+                            externalId: commandExternalId,
+                            tenantId: activity.conversation?.tenantId,
+                            displayName: activity.from?.name || "Unknown",
+                            channel: "teams",
+                        });
+                        const commandContext = await commandResolver.resolve();
+                        (0, context_1.deleteSession)((0, config_2.sessionPath)(commandContext.friend.id, "teams", convId));
+                        await stream.emit("session cleared");
+                        if (_turnCoordinator.isTurnActive(turnKey)) {
+                            _turnCoordinator.enqueueFollowUp(turnKey, {
+                                conversationId: convId,
+                                text,
+                                receivedAt: Date.now(),
+                                effect: "clear_and_supersede",
+                            });
+                        }
+                        return;
+                    }
                 }
-                catch { /* no token yet — tool handler will trigger signin */ }
+            }
+            work = coordinateTeamsTurn(convId, text, {
+                aadObjectId: activity.from?.aadObjectId, userId, tenantId: activity.conversation?.tenantId,
+                replyToId: activity.replyToId,
+            }, async () => {
                 try {
-                    const adoRes = await api.users.token.get({ userId, connectionName: tenantOAuth.adoConnectionName, channelId });
-                    adoToken = adoRes?.token;
+                    // Resolve OAuth connection names for this user's tenant (supports per-tenant overrides).
+                    const tenantId = activity.conversation?.tenantId;
+                    const tenantOAuth = (0, config_1.resolveOAuthForTenant)(tenantId);
+                    // Fetch tokens for both OAuth connections independently.
+                    // Failures are silently caught -- the tool handler will request signin if needed.
+                    let graphToken;
+                    let adoToken;
+                    let githubToken;
+                    try {
+                        const graphRes = await api.users.token.get({ userId, connectionName: tenantOAuth.graphConnectionName, channelId });
+                        graphToken = graphRes?.token;
+                    }
+                    catch { /* no token yet — tool handler will trigger signin */ }
+                    try {
+                        const adoRes = await api.users.token.get({ userId, connectionName: tenantOAuth.adoConnectionName, channelId });
+                        adoToken = adoRes?.token;
+                    }
+                    catch { /* no token yet — tool handler will trigger signin */ }
+                    try {
+                        const githubRes = await api.users.token.get({ userId, connectionName: tenantOAuth.githubConnectionName, channelId });
+                        githubToken = githubRes?.token;
+                    }
+                    catch { /* no token yet — tool handler will trigger signin */ }
+                    (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.token_status", component: "channels", message: "oauth token availability", meta: { graph: !!graphToken, ado: !!adoToken, github: !!githubToken, tenantId } });
+                    const teamsContext = {
+                        inboundActivityId: activity.id,
+                        replyToId: activity.replyToId,
+                        graphToken,
+                        adoToken,
+                        githubToken,
+                        signin: async (cn) => {
+                            try {
+                                const result = await signin({ connectionName: cn });
+                                (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.signin_result", component: "channels", message: `signin(${cn}): ${result ? "token received" : "no token"}`, meta: { connectionName: cn, hasToken: !!result } });
+                                return result;
+                            }
+                            catch (e) {
+                                const msg = e instanceof Error ? e.message : String(e);
+                                (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.signin_error", component: "channels", message: `signin(${cn}) failed`, meta: { connectionName: cn, reason: msg.slice(0, 100) } });
+                                return undefined;
+                            }
+                        },
+                        aadObjectId: activity.from?.aadObjectId,
+                        tenantId: activity.conversation?.tenantId,
+                        displayName: activity.from?.name,
+                        graphConnectionName: tenantOAuth.graphConnectionName,
+                        adoConnectionName: tenantOAuth.adoConnectionName,
+                        githubConnectionName: tenantOAuth.githubConnectionName,
+                        /* v8 ignore next -- bot API availability branch; requires live SDK context @preserve */
+                        botApi: app.id && api ? { id: app.id, conversations: api.conversations } : undefined,
+                        teamsSendImage: (0, teams_image_1.createTeamsImageSender)((message) => ctx.send(message), activity.id, aiLabelEntities()),
+                    };
+                    await handleTeamsMessage(text, stream, convId, teamsContext, sendText);
                 }
-                catch { /* no token yet — tool handler will trigger signin */ }
-                try {
-                    const githubRes = await api.users.token.get({ userId, connectionName: tenantOAuth.githubConnectionName, channelId });
-                    githubToken = githubRes?.token;
+                catch (err) {
+                    reportTeamsRequest("failed", convId, requestContext, { reason: "handler_failed" });
+                    const msg = err instanceof Error ? err.message : String(err);
+                    (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.handler_error", component: "channels", message: msg.slice(0, 200), meta: { conversationId: convId, inboundActivityId: activity.id, botId: app.id } });
                 }
-                catch { /* no token yet — tool handler will trigger signin */ }
-                (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.token_status", component: "channels", message: "oauth token availability", meta: { graph: !!graphToken, ado: !!adoToken, github: !!githubToken, tenantId } });
-                const teamsContext = {
-                    replyToId: activity.replyToId,
-                    graphToken,
-                    adoToken,
-                    githubToken,
-                    signin: async (cn) => {
-                        try {
-                            const result = await signin({ connectionName: cn });
-                            (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.signin_result", component: "channels", message: `signin(${cn}): ${result ? "token received" : "no token"}`, meta: { connectionName: cn, hasToken: !!result } });
-                            return result;
-                        }
-                        catch (e) {
-                            const msg = e instanceof Error ? e.message : String(e);
-                            (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.signin_error", component: "channels", message: `signin(${cn}) failed`, meta: { connectionName: cn, reason: msg.slice(0, 100) } });
-                            return undefined;
-                        }
-                    },
-                    aadObjectId: activity.from?.aadObjectId,
-                    tenantId: activity.conversation?.tenantId,
-                    displayName: activity.from?.name,
-                    graphConnectionName: tenantOAuth.graphConnectionName,
-                    adoConnectionName: tenantOAuth.adoConnectionName,
-                    githubConnectionName: tenantOAuth.githubConnectionName,
-                    /* v8 ignore next -- bot API availability branch; requires live SDK context @preserve */
-                    botApi: app.id && api ? { id: app.id, conversations: api.conversations } : undefined,
-                    teamsSendImage: (0, teams_image_1.createTeamsImageSender)((message) => ctx.send(message), activity.id, aiLabelEntities()),
-                };
-                /* v8 ignore next 5 -- bot-framework integration callback; tested via handleTeamsMessage sendMessage path @preserve */
-                const ctxSend = async (t) => {
-                    // Use send with replyToId (not reply, which adds a blockquote).
-                    // replyToId anchors the message after the user's message in Copilot Chat.
-                    await ctx.send({ type: "message", text: t, replyToId: activity.id, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
-                };
-                await handleTeamsMessage(text, stream, convId, teamsContext, ctxSend);
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.handler_error", component: "channels", message: msg.slice(0, 200), meta: {} });
-            }
+            });
         });
+        await work;
     });
     app.event("error", ({ error }) => {
         const msg = error instanceof Error ? error.message : String(error);
-        (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.app_error", component: "channels", message: `[${label}] ${msg}`, meta: {} });
+        (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.app_error", component: "channels", message: `[${label}] ${msg}`, meta: { botId: app.id, label } });
     });
 }
 function findAadObjectId(friend) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.932",
+  "version": "0.1.0-alpha.934",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.932",
+      "version": "0.1.0-alpha.934",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.932",
+  "version": "0.1.0-alpha.934",
   "engines": {
     "node": ">=22"
   },