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

package/changelog.json

@@ -1,6 +1,15 @@
 {
   "_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.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.933",
   "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.933</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

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

@@ -694,6 +694,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 +758,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;
@@ -962,9 +980,11 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
     }
     catch (error) {
         if (error instanceof session_transaction_1.SessionTurnBusyError || (error instanceof Error && error.name === "SessionTurnBusyError")) {
+            reportTeamsRequest("failed", conversationId, teamsContext, { traceId, reason: "lease_busy" });
             stream.emit("this conversation is busy finishing another turn; please try again");
             return;
         }
+        reportTeamsRequest("failed", conversationId, teamsContext, { traceId, reason: "turn_failed" });
         throw error;
     }
 }
@@ -1159,7 +1179,11 @@ function registerBotHandlers(app, label) {
         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 requestContext = {
+            inboundActivityId: activity.id, tenantId: activity.conversation?.tenantId,
+            botApi: app.id && api ? { id: app.id, conversations: api.conversations } : 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 } });
         const commandRegistry = createTeamsCommandRegistry();
         const parsedSlashCommand = (0, commands_1.parseSlashCommand)(text);
         if (parsedSlashCommand) {
@@ -1200,6 +1224,7 @@ function registerBotHandlers(app, label) {
             replyToId: activity.replyToId,
         }, async () => {
             try {
+                reportTeamsRequest("admitted", convId, requestContext);
                 // 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);
@@ -1225,6 +1250,7 @@ function registerBotHandlers(app, label) {
                 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,
@@ -1255,11 +1281,20 @@ function registerBotHandlers(app, label) {
                 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 } });
+                    try {
+                        const receipt = await ctx.send({ type: "message", text: t, 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, teamsContext, { delivery: messageId ? "accepted" : "unconfirmed", ...(messageId ? { outboundActivityId: messageId } : {}) });
+                    }
+                    catch (error) {
+                        reportTeamsRequest("failed", convId, teamsContext, { reason: "send_unknown" });
+                        throw error;
+                    }
                 };
                 await handleTeamsMessage(text, stream, convId, teamsContext, ctxSend);
             }
             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: {} });
             }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.932",
+  "version": "0.1.0-alpha.933",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.932",
+      "version": "0.1.0-alpha.933",
       "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.933",
   "engines": {
     "node": ">=22"
   },