@integrity-labs/agt-cli 0.28.459 → 0.28.461

package/dist/mcp/direct-chat-channel.js

@@ -34522,6 +34522,12 @@ var FLAG_REGISTRY = [
     // operational decision with blast radius, so mutations require confirmation.
     sensitive: true
   },
+  {
+    key: "promise-outstanding-alarm",
+    description: 'Outstanding-interim-promise alarm (ENG-8265): when ON, the responsiveness-probe route creates a per-agent CloudWatch alarm on `PromiseOutstandingOldestAgeSeconds` \u2014 an inbound the agent acknowledged with an interim reply ("on it") and never answered substantively. Closes the blind spot where an ack satisfied channel-silent-loss, refreshed pending-inbound, and left agent_stall with no in_progress card to see, so a broken promise looked like a served request. Defaults ON (armed on deploy) because the alert it opens is `info` severity \u2014 dashboard-only, never paged \u2014 so a day-one false positive costs a visible row, not a woken human. Flip OFF from the admin Feature Flags page to disarm stage-wide; the window itself is tuned with the AUGMENTED_PROMISE_OUTSTANDING_THRESHOLD_SECONDS API tunable (default 1800).',
+    flagType: "boolean",
+    defaultValue: true
+  },
   {
     key: "connectivity-probe",
     description: "Host-side rolling integration connectivity probe (ENG-5641): when ON, the manager probes each integration ~hourly using the agent's real creds/MCP and reports to /host/integration-connectivity, which populates last_connectivity_* and feeds the central escalation evaluator (integration-connectivity-escalation) and reconnect notifications. It is the only continuous writer of last_connectivity_status (the monitor cron only reads it). Migrated from the raw AGT_CONNECTIVITY_PROBE_ENABLED env gate to this registry flag (ENG-7220) so both halves of the connectivity subsystem are flag-managed; the env var is retained as the highest-precedence operator override (env override > flag value > this default). Boolean gate; ships dark.",

package/dist/mcp/origami.js

@@ -40412,6 +40412,12 @@ var FLAG_REGISTRY = [
     // operational decision with blast radius, so mutations require confirmation.
     sensitive: true
   },
+  {
+    key: "promise-outstanding-alarm",
+    description: 'Outstanding-interim-promise alarm (ENG-8265): when ON, the responsiveness-probe route creates a per-agent CloudWatch alarm on `PromiseOutstandingOldestAgeSeconds` \u2014 an inbound the agent acknowledged with an interim reply ("on it") and never answered substantively. Closes the blind spot where an ack satisfied channel-silent-loss, refreshed pending-inbound, and left agent_stall with no in_progress card to see, so a broken promise looked like a served request. Defaults ON (armed on deploy) because the alert it opens is `info` severity \u2014 dashboard-only, never paged \u2014 so a day-one false positive costs a visible row, not a woken human. Flip OFF from the admin Feature Flags page to disarm stage-wide; the window itself is tuned with the AUGMENTED_PROMISE_OUTSTANDING_THRESHOLD_SECONDS API tunable (default 1800).',
+    flagType: "boolean",
+    defaultValue: true
+  },
   {
     key: "connectivity-probe",
     description: "Host-side rolling integration connectivity probe (ENG-5641): when ON, the manager probes each integration ~hourly using the agent's real creds/MCP and reports to /host/integration-connectivity, which populates last_connectivity_* and feeds the central escalation evaluator (integration-connectivity-escalation) and reconnect notifications. It is the only continuous writer of last_connectivity_status (the monitor cron only reads it). Migrated from the raw AGT_CONNECTIVITY_PROBE_ENABLED env gate to this registry flag (ENG-7220) so both halves of the connectivity subsystem are flag-managed; the env var is retained as the highest-precedence operator override (env override > flag value > this default). Boolean gate; ships dark.",

package/dist/mcp/slack-channel.js

@@ -34752,6 +34752,12 @@ var FLAG_REGISTRY = [
     // operational decision with blast radius, so mutations require confirmation.
     sensitive: true
   },
+  {
+    key: "promise-outstanding-alarm",
+    description: 'Outstanding-interim-promise alarm (ENG-8265): when ON, the responsiveness-probe route creates a per-agent CloudWatch alarm on `PromiseOutstandingOldestAgeSeconds` \u2014 an inbound the agent acknowledged with an interim reply ("on it") and never answered substantively. Closes the blind spot where an ack satisfied channel-silent-loss, refreshed pending-inbound, and left agent_stall with no in_progress card to see, so a broken promise looked like a served request. Defaults ON (armed on deploy) because the alert it opens is `info` severity \u2014 dashboard-only, never paged \u2014 so a day-one false positive costs a visible row, not a woken human. Flip OFF from the admin Feature Flags page to disarm stage-wide; the window itself is tuned with the AUGMENTED_PROMISE_OUTSTANDING_THRESHOLD_SECONDS API tunable (default 1800).',
+    flagType: "boolean",
+    defaultValue: true
+  },
   {
     key: "connectivity-probe",
     description: "Host-side rolling integration connectivity probe (ENG-5641): when ON, the manager probes each integration ~hourly using the agent's real creds/MCP and reports to /host/integration-connectivity, which populates last_connectivity_* and feeds the central escalation evaluator (integration-connectivity-escalation) and reconnect notifications. It is the only continuous writer of last_connectivity_status (the monitor cron only reads it). Migrated from the raw AGT_CONNECTIVITY_PROBE_ENABLED env gate to this registry flag (ENG-7220) so both halves of the connectivity subsystem are flag-managed; the env var is retained as the highest-precedence operator override (env override > flag value > this default). Boolean gate; ships dark.",
@@ -37350,6 +37356,30 @@ function clearOldestSlackPendingMarkerInChannel(dir, channel, clear = defaultCle
   }
 }
 
+// ../core/dist/channels/interim-promise.js
+function decideMarkerEngagement(marker, kind, nowIso) {
+  const alreadySeen = typeof marker?.seen_at === "string" && marker.seen_at !== "";
+  const alreadyPromised = typeof marker?.promised_at === "string" && marker.promised_at !== "";
+  if (kind === "seen") {
+    return alreadySeen ? { stamp: null, promised: alreadyPromised } : { stamp: { seen_at: nowIso }, promised: alreadyPromised };
+  }
+  if (alreadyPromised)
+    return { stamp: null, promised: true };
+  return {
+    stamp: alreadySeen ? { promised_at: nowIso } : { seen_at: nowIso, promised_at: nowIso },
+    promised: true
+  };
+}
+function describePromiseStampOutcome(tally, replyToolName) {
+  if (tally.attempted > tally.stamped) {
+    return "WARNING: this was recorded as an interim ack but the outstanding-promise marker could NOT be written, so nothing is tracking that you still owe a final reply. Do not rely on a reminder \u2014 post your substantive answer in this same turn.";
+  }
+  if (tally.stamped > 0) {
+    return `Recorded as an interim ack \u2014 your final answer is still owed and is being tracked until you send it as a separate ${replyToolName} with interim omitted.`;
+  }
+  return null;
+}
+
 // src/recovery-ledger.ts
 import { existsSync as existsSync5, unlinkSync as unlinkSync2 } from "fs";
 import { join as join11 } from "path";
@@ -40301,16 +40331,34 @@ function rewriteSlackMarkerInPlace(path, marker) {
   }
 }
 function markSlackMarkerSeenInPlace(fullPath) {
+  markSlackMarkerEngagedInPlace(fullPath, { promise: false });
+}
+function markSlackMarkerPromisedInPlace(fullPath) {
+  return markSlackMarkerEngagedInPlace(fullPath, { promise: true });
+}
+function markSlackMarkerEngagedInPlace(fullPath, opts) {
   let marker;
   try {
     marker = JSON.parse(readFileSync21(fullPath, "utf-8"));
   } catch {
-    return;
+    return false;
   }
-  if (marker.seen_at) return;
-  marker.seen_at = (/* @__PURE__ */ new Date()).toISOString();
+  const decision = decideMarkerEngagement(
+    marker,
+    opts.promise ? "interim_ack" : "seen",
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+  if (!decision.stamp) return opts.promise ? decision.promised : false;
+  Object.assign(marker, decision.stamp);
   if (marker.undeliverable) delete marker.undeliverable;
   rewriteSlackMarkerInPlace(fullPath, marker);
+  if (!opts.promise) return false;
+  try {
+    const readBack = JSON.parse(readFileSync21(fullPath, "utf-8"));
+    return typeof readBack.promised_at === "string" && readBack.promised_at.length > 0;
+  } catch {
+    return false;
+  }
 }
 function attachSlackReplayPayload(channel, threadTs, messageTs, payload) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
@@ -40493,11 +40541,20 @@ function clearSlackMarkerFileWithHeal(fullPath) {
   }
 }
 function markSlackMarkerSeenWithHeal(fullPath) {
+  healThenEngageSlackMarker(fullPath, { promise: false });
+}
+function markSlackMarkerPromisedWithHeal(fullPath) {
+  const stamped = healThenEngageSlackMarker(fullPath, { promise: true });
+  slackPromiseStampOutcome.attempted += 1;
+  if (stamped) slackPromiseStampOutcome.stamped += 1;
+}
+var slackPromiseStampOutcome = { attempted: 0, stamped: 0 };
+function healThenEngageSlackMarker(fullPath, opts) {
   let marker = null;
   try {
     marker = JSON.parse(readFileSync21(fullPath, "utf-8"));
   } catch {
-    return;
+    return false;
   }
   if (decideRecoveryHeal({
     wasUndeliverable: marker.undeliverable === true,
@@ -40506,7 +40563,7 @@ function markSlackMarkerSeenWithHeal(fullPath) {
     healSlackUndeliverable(marker.channel, marker.message_ts);
     deleteSlackUndeliverableNotice(undeliverableNoticeConversationKeyFromMarker(marker));
   }
-  markSlackMarkerSeenInPlace(fullPath);
+  return opts.promise ? markSlackMarkerPromisedInPlace(fullPath) : (markSlackMarkerSeenInPlace(fullPath), false);
 }
 function clearAllSlackPendingMarkersForThread2(channel, threadTs) {
   clearAllSlackPendingMarkersForThread(
@@ -40550,6 +40607,22 @@ function markSeenSlackPendingMarkerByMessageTs2(channel, messageTs) {
     markSlackMarkerSeenWithHeal
   );
 }
+function markPromisedAllSlackPendingMarkersForThread(channel, threadTs) {
+  markSeenAllSlackPendingMarkersForThread(
+    SLACK_PENDING_INBOUND_DIR,
+    channel,
+    threadTs,
+    markSlackMarkerPromisedWithHeal
+  );
+}
+function markPromisedSlackPendingMarkerByMessageTs(channel, messageTs) {
+  markSeenSlackPendingMarkerByMessageTs(
+    SLACK_PENDING_INBOUND_DIR,
+    channel,
+    messageTs,
+    markSlackMarkerPromisedWithHeal
+  );
+}
 function slackNextRetryName(filename) {
   const match = filename.match(/^(.*?)(?:\.retry-(\d+))?\.json$/);
   if (!match) return null;
@@ -43073,17 +43146,19 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     const settleChannel = effectiveChannel;
     const settleMessageTs = effectiveMessageTs;
     const settlePendingMarker = () => {
+      slackPromiseStampOutcome.attempted = 0;
+      slackPromiseStampOutcome.stamped = 0;
       if (!settleChannel) return;
       if (settleMessageTs) {
         if (interim) {
-          markSeenSlackPendingMarkerByMessageTs2(settleChannel, settleMessageTs);
-          if (settleThreadTs) markSeenAllSlackPendingMarkersForThread2(settleChannel, settleThreadTs);
+          markPromisedSlackPendingMarkerByMessageTs(settleChannel, settleMessageTs);
+          if (settleThreadTs) markPromisedAllSlackPendingMarkersForThread(settleChannel, settleThreadTs);
         } else {
           clearSlackPendingMarkerByMessageTs2(settleChannel, settleMessageTs);
           if (settleThreadTs) clearPendingMessage(settleChannel, settleThreadTs);
         }
       } else if (settleThreadTs) {
-        if (interim) markSeenAllSlackPendingMarkersForThread2(settleChannel, settleThreadTs);
+        if (interim) markPromisedAllSlackPendingMarkersForThread(settleChannel, settleThreadTs);
         else clearPendingMessage(settleChannel, settleThreadTs);
       } else if (!interim) {
         clearOldestSlackPendingMarkerInChannel2(settleChannel);
@@ -43169,6 +43244,16 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         reason: scheduledDest?.retargeted ? "scheduled-task" : channelGuard.corrected ? "dm-channel-guard" : null
       });
       if (redirectNote) base += `. ${redirectNote}`;
+      if (interim) {
+        const promiseNote = describePromiseStampOutcome(slackPromiseStampOutcome, "slack.reply");
+        if (promiseNote) base += `. ${promiseNote}`;
+        if (slackPromiseStampOutcome.attempted > slackPromiseStampOutcome.stamped) {
+          process.stderr.write(
+            `slack-channel(${AGENT_CODE_NAME}): promise_stamp_failed channel=${redactSlackId(effectiveChannel)} attempted=${slackPromiseStampOutcome.attempted} stamped=${slackPromiseStampOutcome.stamped}
+`
+          );
+        }
+      }
       const sentTs = typeof data.ts === "string" ? data.ts : void 0;
       await maybeSendSlackAccountWarn({ channel: effectiveChannel, threadTs: effectiveThreadTs });
       return {

package/dist/mcp/telegram-channel.js

@@ -30145,6 +30145,30 @@ import {
 import { homedir as homedir7 } from "os";
 import { basename, extname, join as join17, resolve as resolve2 } from "path";
 
+// ../core/dist/channels/interim-promise.js
+function decideMarkerEngagement(marker, kind, nowIso) {
+  const alreadySeen = typeof marker?.seen_at === "string" && marker.seen_at !== "";
+  const alreadyPromised = typeof marker?.promised_at === "string" && marker.promised_at !== "";
+  if (kind === "seen") {
+    return alreadySeen ? { stamp: null, promised: alreadyPromised } : { stamp: { seen_at: nowIso }, promised: alreadyPromised };
+  }
+  if (alreadyPromised)
+    return { stamp: null, promised: true };
+  return {
+    stamp: alreadySeen ? { promised_at: nowIso } : { seen_at: nowIso, promised_at: nowIso },
+    promised: true
+  };
+}
+function describePromiseStampOutcome(tally, replyToolName) {
+  if (tally.attempted > tally.stamped) {
+    return "WARNING: this was recorded as an interim ack but the outstanding-promise marker could NOT be written, so nothing is tracking that you still owe a final reply. Do not rely on a reminder \u2014 post your substantive answer in this same turn.";
+  }
+  if (tally.stamped > 0) {
+    return `Recorded as an interim ack \u2014 your final answer is still owed and is being tracked until you send it as a separate ${replyToolName} with interim omitted.`;
+  }
+  return null;
+}
+
 // src/channel-attachments.ts
 import { homedir } from "os";
 import { join, resolve, sep } from "path";
@@ -35054,6 +35078,12 @@ var FLAG_REGISTRY = [
     // operational decision with blast radius, so mutations require confirmation.
     sensitive: true
   },
+  {
+    key: "promise-outstanding-alarm",
+    description: 'Outstanding-interim-promise alarm (ENG-8265): when ON, the responsiveness-probe route creates a per-agent CloudWatch alarm on `PromiseOutstandingOldestAgeSeconds` \u2014 an inbound the agent acknowledged with an interim reply ("on it") and never answered substantively. Closes the blind spot where an ack satisfied channel-silent-loss, refreshed pending-inbound, and left agent_stall with no in_progress card to see, so a broken promise looked like a served request. Defaults ON (armed on deploy) because the alert it opens is `info` severity \u2014 dashboard-only, never paged \u2014 so a day-one false positive costs a visible row, not a woken human. Flip OFF from the admin Feature Flags page to disarm stage-wide; the window itself is tuned with the AUGMENTED_PROMISE_OUTSTANDING_THRESHOLD_SECONDS API tunable (default 1800).',
+    flagType: "boolean",
+    defaultValue: true
+  },
   {
     key: "connectivity-probe",
     description: "Host-side rolling integration connectivity probe (ENG-5641): when ON, the manager probes each integration ~hourly using the agent's real creds/MCP and reports to /host/integration-connectivity, which populates last_connectivity_* and feeds the central escalation evaluator (integration-connectivity-escalation) and reconnect notifications. It is the only continuous writer of last_connectivity_status (the monitor cron only reads it). Migrated from the raw AGT_CONNECTIVITY_PROBE_ENABLED env gate to this registry flag (ENG-7220) so both halves of the connectivity subsystem are flag-managed; the env var is retained as the highest-precedence operator override (env override > flag value > this default). Boolean gate; ships dark.",
@@ -40278,16 +40308,34 @@ function clearTelegramMarkerFileWithHeal(fullPath) {
   }
 }
 function markTelegramMarkerSeenInPlace(fullPath) {
+  markTelegramMarkerEngagedInPlace(fullPath, { promise: false });
+}
+function markTelegramMarkerPromisedInPlace(fullPath) {
+  return markTelegramMarkerEngagedInPlace(fullPath, { promise: true });
+}
+function markTelegramMarkerEngagedInPlace(fullPath, opts) {
   let marker;
   try {
     marker = JSON.parse(readFileSync17(fullPath, "utf-8"));
   } catch {
-    return;
+    return false;
   }
-  if (marker.seen_at) return;
-  marker.seen_at = (/* @__PURE__ */ new Date()).toISOString();
+  const decision = decideMarkerEngagement(
+    marker,
+    opts.promise ? "interim_ack" : "seen",
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+  if (!decision.stamp) return opts.promise ? decision.promised : false;
+  Object.assign(marker, decision.stamp);
   if (marker.undeliverable) delete marker.undeliverable;
   rewriteTelegramMarkerInPlace(fullPath, marker);
+  if (!opts.promise) return false;
+  try {
+    const readBack = JSON.parse(readFileSync17(fullPath, "utf-8"));
+    return typeof readBack.promised_at === "string" && readBack.promised_at.length > 0;
+  } catch {
+    return false;
+  }
 }
 function markTelegramMarkerSeenWithHeal(fullPath) {
   let marker = null;
@@ -40304,6 +40352,23 @@ function markTelegramMarkerSeenWithHeal(fullPath) {
   }
   markTelegramMarkerSeenInPlace(fullPath);
 }
+function markTelegramMarkerPromisedWithHeal(fullPath) {
+  let marker = null;
+  try {
+    marker = JSON.parse(readFileSync17(fullPath, "utf-8"));
+  } catch {
+    return;
+  }
+  if (decideRecoveryHeal({
+    wasUndeliverable: marker.undeliverable === true,
+    hasTarget: Boolean(marker.chat_id)
+  }) === "heal") {
+    notifyBackOnline(marker.chat_id);
+  }
+  telegramPromiseStampOutcome.attempted += 1;
+  if (markTelegramMarkerPromisedInPlace(fullPath)) telegramPromiseStampOutcome.stamped += 1;
+}
+var telegramPromiseStampOutcome = { attempted: 0, stamped: 0 };
 function readPendingInboundMarker(chatId, messageId) {
   const path = pendingInboundPath(chatId, messageId);
   if (!path || !existsSync9(path)) return null;
@@ -41066,6 +41131,23 @@ function markSeenPendingMessage(chatId, cutoffMs = Number.POSITIVE_INFINITY) {
     cutoffMs
   );
 }
+function markPromisedPendingMessage(chatId, cutoffMs = Number.POSITIVE_INFINITY) {
+  telegramPromiseStampOutcome.attempted = 0;
+  telegramPromiseStampOutcome.stamped = 0;
+  if (!PENDING_INBOUND_DIR || !existsSync9(PENDING_INBOUND_DIR)) return;
+  markSeenAllTelegramPendingMarkersForChat(
+    PENDING_INBOUND_DIR,
+    chatId,
+    markTelegramMarkerPromisedWithHeal,
+    cutoffMs
+  );
+  if (telegramPromiseStampOutcome.attempted > telegramPromiseStampOutcome.stamped) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): promise_stamp_failed chat=${redactId(chatId)} attempted=${telegramPromiseStampOutcome.attempted} stamped=${telegramPromiseStampOutcome.stamped}
+`
+    );
+  }
+}
 function noteThreadActivity(chatId, cutoffMs = Number.POSITIVE_INFINITY) {
   if (!chatId) return;
   markSeenPendingMessage(chatId, cutoffMs);
@@ -41481,9 +41563,14 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         };
       }
       recordReply(chat_id, "", tgThrottleNow, tgThrottleCfg);
+      let promiseNote = null;
       if (name === "telegram.reply") {
-        if (interim) markSeenPendingMessage(chat_id, drainCutoffMs);
-        else clearPendingMessage(chat_id, drainCutoffMs);
+        if (interim) {
+          markPromisedPendingMessage(chat_id, drainCutoffMs);
+          promiseNote = describePromiseStampOutcome(telegramPromiseStampOutcome, "telegram.reply");
+        } else {
+          clearPendingMessage(chat_id, drainCutoffMs);
+        }
         writeInboundDeliveryLedgerEntry(DELIVERY_LEDGER_DIR, {
           inbound_id: telegramInboundId(chat_id, reply_to_message_id ? String(reply_to_message_id) : ""),
           source: "telegram",
@@ -41492,7 +41579,9 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         });
       }
       await maybeSendTelegramAccountWarn({ chatId: chat_id });
-      return { content: [{ type: "text", text: "sent" }] };
+      return {
+        content: [{ type: "text", text: promiseNote ? `sent. ${promiseNote}` : "sent" }]
+      };
     } catch (err) {
       return {
         content: [{ type: "text", text: `Failed: ${err.message}` }],

package/dist/{persistent-session-KGRCIIS5.js → persistent-session-HRVZVAIL.js}

@@ -36,7 +36,7 @@ import {
   writeDirectChatSessionState,
   writeEgressAllowlist,
   writePersistentClaudeWrapper
-} from "./chunk-BWH5XTDU.js";
+} from "./chunk-QZUECTC7.js";
 import "./chunk-XWVM4KPK.js";
 export {
   EGRESS_BASELINE_DOMAINS,
@@ -77,4 +77,4 @@ export {
   writeEgressAllowlist,
   writePersistentClaudeWrapper
 };
-//# sourceMappingURL=persistent-session-KGRCIIS5.js.map
+//# sourceMappingURL=persistent-session-HRVZVAIL.js.map