@integrity-labs/agt-cli 0.28.337 → 0.28.339

package/dist/{claude-pair-runtime-T7EFAWS5.js → claude-pair-runtime-F55PDOWQ.js}

@@ -100,7 +100,7 @@ async function spawnPairSession(session) {
     return { ok: true };
   } catch {
   }
-  const { resolveClaudeBinary } = await import("./persistent-session-ENQXJNBJ.js");
+  const { resolveClaudeBinary } = await import("./persistent-session-4UG3S54C.js");
   const claudeBin = resolveClaudeBinary();
   const pairEnv = {
     ...process.env,
@@ -373,4 +373,4 @@ export {
   startClaudePair,
   submitClaudePairCode
 };
-//# sourceMappingURL=claude-pair-runtime-T7EFAWS5.js.map
+//# sourceMappingURL=claude-pair-runtime-F55PDOWQ.js.map

package/dist/lib/manager-worker.js

@@ -45,7 +45,7 @@ import {
   requireHost,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-N7XPDFCW.js";
+} from "../chunk-UVMGRGRO.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -134,7 +134,7 @@ import {
   takeZombieDetection,
   transcriptActivityAgeSeconds,
   writeEgressAllowlist
-} from "../chunk-J2WYEOBH.js";
+} from "../chunk-J6QDPXGS.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
@@ -8388,7 +8388,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.337" : "dev";
+var agtCliVersion = true ? "0.28.339" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -9343,7 +9343,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-ENQXJNBJ.js");
+      const { collectDiagnostics } = await import("../persistent-session-4UG3S54C.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames)
@@ -9442,7 +9442,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-ENQXJNBJ.js");
+      const { collectDiagnostics } = await import("../persistent-session-4UG3S54C.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -9591,7 +9591,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-46XFHCPY.js");
+      } = await import("../responsiveness-probe-TK47IXPX.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -9623,7 +9623,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-46XFHCPY.js");
+        } = await import("../responsiveness-probe-TK47IXPX.js");
         const { getProjectDir: wedgeProjectDir } = await import("../claude-scheduler-FATCLHDM.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -12721,7 +12721,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
     void api.post("/host/restart-ack", { host_id: hostId, agent_id: agentId, restart_requested_at: requestedAt }).catch((err) => log(`[restart-lane] ack failed for '${codeName}': ${err.message}`));
     void (async () => {
       try {
-        const { collectDiagnostics } = await import("../persistent-session-ENQXJNBJ.js");
+        const { collectDiagnostics } = await import("../persistent-session-4UG3S54C.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName])
@@ -12771,7 +12771,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-ENQXJNBJ.js");
+      const { collectDiagnostics } = await import("../persistent-session-4UG3S54C.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName])
@@ -13269,7 +13269,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-T7EFAWS5.js");
+  } = await import("../claude-pair-runtime-F55PDOWQ.js");
   for (const pairId of pendingResp.cancelled_pair_ids ?? []) {
     log(`[claude-pair] sweeping orphan tmux session for pair ${pairId.slice(0, 8)}`);
     const killed = await killPairSession(pairTmuxSession(pairId));

package/dist/mcp/origami.js

@@ -40139,6 +40139,24 @@ var FLAG_REGISTRY = [
     // change (ADR-0022 sensitive-flag confirm).
     sensitive: true
   },
+  {
+    key: "slack-hot-thread-guard",
+    description: "Server-side hot-thread guard on the slack.reply surface (ENG-7462). Prevents an agent posting a NEW top-level Slack message when it meant to reply inside the thread it is already working in - a prompt/memory rule proved insufficient (the agent had the rule and still slipped). When a reply would otherwise post to channel ROOT (no thread_ts / message_ts / inbound_id, no active kanban card) and the agent has a recent active thread in that channel (its last bot-posted thread, from the persisted trackedThreads cache, within a freshness window), the reply is redirected into that thread. proactive:true no longer implies channel root; posting at root becomes a deliberate action (the to_channel_root flag, or the thread_ts:null sentinel). off = guard never runs, replies with no coords root exactly as today (ships dark). shadow = compute + log the would-redirect but STILL post to root (measure the fire rate before acting). enforce = apply the redirect (a soft-block: redirect + inform, never a hard rejection). Read live from the heartbeat flags-cache (or the env override); enforce is a deliberate per-org flip after a shadow soak.",
+    flagType: "enum",
+    allowedValues: ["off", "shadow", "enforce"],
+    // Ships dark: off preserves today's behaviour exactly (a coordless reply
+    // roots). shadow is a free local log line (no model spend, unlike ghost-reply)
+    // so it is a cheap opt-in soak; enforce changes where a reply lands, so it is
+    // the audited flip.
+    defaultValue: "off",
+    // Enum override AGT_SLACK_HOT_THREAD_GUARD_MODE (off|shadow|enforce),
+    // resolved by resolveSlackHotThreadMode in the channel-server bundle.
+    envVar: "AGT_SLACK_HOT_THREAD_GUARD_MODE",
+    // enforce reroutes a message the agent asked to send to channel root into a
+    // thread - a visible destination change, so flipping toward it is deliberate
+    // (ADR-0022 sensitive-flag confirm).
+    sensitive: true
+  },
   {
     key: "compaction-notice",
     description: 'Compaction courtesy notice (ENG-7339): when a managed Claude Code session compacts its context, the persistent session pauses and stops replying for a stretch, which looks identical to a dead agent from the channel. When ON, the generated PreCompact hook finds the conversation the user is actively on (the last <channel ...> tag in the transcript) and drops a notice into the matching <channel>-notice-outbox; the channel MCP server (alive while the Claude process compacts) posts a short "reorganizing my memory, back shortly" line. The notice path never clears the pending-inbound marker, so the genuine reply the agent still owes after compaction is unaffected. No active channel tag \u21D2 silent (idle agents never broadcast). Boolean gate; ships dark, canary per host before any fleet flip. When OFF the hook writes nothing and the consumer drops any stray notice unsent.',
@@ -40449,6 +40467,18 @@ var FLAG_REGISTRY = [
     // egress + workflow change worth an explicit confirm.
     sensitive: true
   },
+  {
+    key: "email-guard-per-scope-stage",
+    description: "Per-agent / per-team email-domain guardrail rollout stage (ENG-7830 / ADR-0048). When ON for an org, the effective email_guard_stage is resolved most-specific-non-null (agent ?? team ?? org, with time-boxed exemption decay), so one agent can run shadow while the org is enforce (and vice-versa). When OFF (default) the stage is org-grain only (pre-ENG-7830 behaviour) - the per-agent/team email_guard_stage columns are ignored. Gates the resolver seam (getEffectiveEmailGuardStage) and the owner/admin write routes. Evaluated per-org. Ships dark.",
+    flagType: "boolean",
+    // Declared safe value is `false` (org-only stage = today's behaviour). A flag-DB
+    // read error degrades here, so the per-scope columns stay ignored and the org
+    // policy governs - the fail-closed direction for a compliance control.
+    defaultValue: false,
+    // Enabling it lets a lower scope LOOSEN an email compliance control per-agent, so
+    // flipping it on is worth an explicit confirm (ADR-0022 §4).
+    sensitive: true
+  },
   {
     key: "slack-reply-binding",
     description: "Slack reply-target binding (ENG-7396 / WS2, cross-thread reply routing): the model names which inbound it answers (inbound_id) and the server resolves the destination from its own verified record. shadow = classify + count only, routing unchanged; warn = same routing plus a tool-result note so the model self-corrects; enforce = route a bound reply to the registry thread and REJECT a reply whose target matches no inbound this process delivered. The channel server can't evaluate flags, so the manager materializes the resolved value into the AGT_SLACK_REPLY_BINDING spawn env (the operator/canary override, ADR-0022). Ships shadow.",

package/dist/mcp/slack-channel.js

@@ -14744,6 +14744,40 @@ function resolveGhostReplyMode(opts) {
   if (cached2 !== void 0) return cached2;
   return "off";
 }
+var SLACK_HOT_THREAD_FLAG_KEY = "slack-hot-thread-guard";
+function parseSlackHotThreadMode(raw) {
+  if (raw === void 0) return void 0;
+  const v = raw.trim().toLowerCase();
+  if (v === "") return void 0;
+  if (v === "off" || v === "shadow" || v === "enforce") return v;
+  const b = envBoolean(raw);
+  if (b === true) return "enforce";
+  if (b === false) return "off";
+  return void 0;
+}
+function cachedSlackHotThreadMode(path) {
+  try {
+    if (!existsSync(path)) return void 0;
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const flags = parsed.flags;
+    if (!flags || typeof flags !== "object") return void 0;
+    const value = flags[SLACK_HOT_THREAD_FLAG_KEY];
+    if (typeof value === "string") return parseSlackHotThreadMode(value);
+    if (typeof value === "boolean") return value ? "enforce" : "off";
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveSlackHotThreadMode(opts) {
+  const env = opts?.env ?? process.env;
+  const modeOverride = parseSlackHotThreadMode(env["AGT_SLACK_HOT_THREAD_GUARD_MODE"]);
+  if (modeOverride !== void 0) return modeOverride;
+  const cached2 = cachedSlackHotThreadMode(opts?.cachePath ?? defaultFlagsCachePath());
+  if (cached2 !== void 0) return cached2;
+  return "off";
+}
 
 // src/maintenance-mode.ts
 var FLAG_KEY = "platform-maintenance-mode";
@@ -16412,6 +16446,47 @@ function resolveReplyThreadTs(input) {
   return input.activeCardThreadTs || void 0;
 }
 
+// src/slack-hot-thread.ts
+function parseThreadKey(key2) {
+  const idx = key2.indexOf(":");
+  if (idx <= 0 || idx >= key2.length - 1) return null;
+  return { channel: key2.slice(0, idx), threadTs: key2.slice(idx + 1) };
+}
+function resolveHotThread(input) {
+  const { channel, trackedThreads: trackedThreads2, now, windowMs } = input;
+  if (!channel || windowMs <= 0) return void 0;
+  let bestThreadTs;
+  let bestSeenMs = -Infinity;
+  const floor = now - windowMs;
+  for (const [key2, entry] of trackedThreads2) {
+    if (entry?.bot_posted !== true) continue;
+    const parsed = parseThreadKey(key2);
+    if (!parsed || parsed.channel !== channel) continue;
+    const seenMs = Date.parse(entry.last_seen_at);
+    if (!Number.isFinite(seenMs)) continue;
+    if (seenMs < floor || seenMs > now) continue;
+    if (seenMs > bestSeenMs || seenMs === bestSeenMs && (bestThreadTs === void 0 || parsed.threadTs > bestThreadTs)) {
+      bestSeenMs = seenMs;
+      bestThreadTs = parsed.threadTs;
+    }
+  }
+  if (bestThreadTs === void 0) return void 0;
+  return { threadTs: bestThreadTs, ageMs: Math.max(0, now - bestSeenMs) };
+}
+function applyHotThreadGuard(input) {
+  const { baseThreadTs, forcedRoot, hotThread } = input;
+  if (forcedRoot) {
+    return { threadTs: void 0, guard: "root_forced" };
+  }
+  if (baseThreadTs !== void 0) {
+    return { threadTs: baseThreadTs, guard: "not_applicable" };
+  }
+  if (hotThread) {
+    return { threadTs: hotThread.threadTs, guard: "redirected_to_hot_thread" };
+  }
+  return { threadTs: void 0, guard: "root_no_hot_thread" };
+}
+
 // src/restart-confirm.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
 import { dirname } from "path";
@@ -20741,6 +20816,15 @@ var trackedThreads = /* @__PURE__ */ new Map();
 var THREAD_STORE_PATH = resolveThreadStorePath();
 var THREAD_STORE_TTL_DAYS = parseTtlDays(process.env.SLACK_THREAD_FOLLOW_TTL_DAYS);
 var threadPersister = null;
+var SLACK_HOT_THREAD_DEFAULT_WINDOW_MS = 15 * 60 * 1e3;
+function parseHotThreadWindowMs(raw) {
+  if (!raw) return SLACK_HOT_THREAD_DEFAULT_WINDOW_MS;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : SLACK_HOT_THREAD_DEFAULT_WINDOW_MS;
+}
+var SLACK_HOT_THREAD_WINDOW_MS = parseHotThreadWindowMs(
+  process.env.AGT_SLACK_HOT_THREAD_WINDOW_MS
+);
 function resolveThreadStorePath() {
   if (!AGENT_CODE_NAME) return null;
   return join16(homedir4(), ".augmented", AGENT_CODE_NAME, "slack-tracked-threads.json");
@@ -20913,7 +20997,15 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
           },
           proactive: {
             type: "boolean",
-            description: "Set true ONLY when this message is NOT a reply to any inbound <channel> tag - a self-initiated outreach or scheduled-task output. Leave it off (default) for every reply to a user message."
+            description: 'Set true ONLY when this message is NOT a reply to any inbound <channel> tag - a self-initiated outreach or scheduled-task output. Leave it off (default) for every reply to a user message. Note: proactive does NOT mean "post at the channel root". If you are actively working in a thread, a proactive message still threads into it. To deliberately start a NEW top-level message in the channel, also set to_channel_root:true.'
+          },
+          // ENG-7462: the explicit, deliberate escape to a channel-root post. The
+          // server defaults a coordless reply INTO the thread you are actively
+          // working in (the hot-thread guard); starting a genuinely new top-level
+          // conversation is a separate, deliberate action signalled here.
+          to_channel_root: {
+            type: "boolean",
+            description: "Set true to DELIBERATELY post a new top-level message at the channel root instead of threading into the conversation you are currently working in. Use it only when you genuinely want to start a new topic in the channel (not a reply to, or a continuation of, an existing thread). Leave it off (default) for anything that belongs in an ongoing thread."
           }
         },
         required: ["channel", "text"]
@@ -21190,7 +21282,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     return buildImpersonationRefusal(name);
   }
   if (name === "slack.reply") {
-    const { channel, text, thread_ts, message_ts, interim, inbound_id, proactive } = args;
+    const { channel, text, thread_ts, message_ts, interim, inbound_id, proactive, to_channel_root } = args;
     const bindingMode = slackReplyBindingMode();
     const binding = resolveReplyBinding({
       mode: bindingMode,
@@ -21259,13 +21351,37 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
       };
     }
     const bindingFeedback = bindingMode === "warn" ? binding.agentFeedback : void 0;
-    const activeCardThreadTs = !scheduledDest && !enforceBound && !channelGuard.corrected && !thread_ts && !message_ts && kanbanCardActiveClient && typeof channel === "string" && channel ? await kanbanCardActiveClient.getActiveCardSourceThread("slack", channel) : void 0;
-    const effectiveThreadTs = scheduledDest ? scheduledDest.thread_ts : enforceBound ? binding.threadTs : channelGuard.corrected ? channelGuard.threadTs : resolveReplyThreadTs({
+    const forcedRoot = to_channel_root === true || thread_ts === null;
+    const activeCardThreadTs = !scheduledDest && !enforceBound && !channelGuard.corrected && !forcedRoot && !thread_ts && !message_ts && kanbanCardActiveClient && typeof channel === "string" && channel ? await kanbanCardActiveClient.getActiveCardSourceThread("slack", channel) : void 0;
+    const plainReply = !scheduledDest && !enforceBound && !channelGuard.corrected;
+    const baseThreadTs = plainReply && !forcedRoot ? resolveReplyThreadTs({
       channel,
       threadTs: thread_ts,
       messageTs: message_ts,
       activeCardThreadTs
-    });
+    }) : void 0;
+    let hotThreadMode = "off";
+    let hotGuard = null;
+    if (plainReply) {
+      hotThreadMode = resolveSlackHotThreadMode();
+      if (hotThreadMode !== "off") {
+        const hotThread = resolveHotThread({
+          channel,
+          trackedThreads,
+          now: Date.now(),
+          windowMs: SLACK_HOT_THREAD_WINDOW_MS
+        });
+        hotGuard = applyHotThreadGuard({ baseThreadTs, forcedRoot, hotThread });
+        if (hotGuard.guard === "redirected_to_hot_thread") {
+          process.stderr.write(
+            `slack-channel(${AGENT_CODE_NAME}): hot_thread_guard mode=${hotThreadMode} applied=${hotThreadMode === "enforce"} channel=${redactSlackId(channel)} hot_thread=${redactSlackId(hotGuard.threadTs)} proactive=${proactive === true} age_ms=${hotThread?.ageMs ?? ""}
+`
+          );
+        }
+      }
+    }
+    const effectiveThreadTs = scheduledDest ? scheduledDest.thread_ts : enforceBound ? binding.threadTs : channelGuard.corrected ? channelGuard.threadTs : hotThreadMode === "enforce" && hotGuard ? hotGuard.threadTs : baseThreadTs;
+    const hotThreadRedirected = hotThreadMode === "enforce" && hotGuard?.guard === "redirected_to_hot_thread";
     if (effectiveChannel) {
       recordReplyTargetClassification(
         SLACK_AGENT_DIR,
@@ -21402,7 +21518,10 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
           }
         })();
       }
-      const base = bindingFeedback ? `sent. ${bindingFeedback}` : "sent";
+      let base = bindingFeedback ? `sent. ${bindingFeedback}` : "sent";
+      if (hotThreadRedirected) {
+        base += ". Note: this was threaded into the conversation you are actively working in rather than posted at the channel root. If you genuinely meant to start a NEW top-level topic, resend with to_channel_root:true.";
+      }
       const sentTs = typeof data.ts === "string" ? data.ts : void 0;
       return {
         content: [{ type: "text", text: sentTs ? `${base} (ts=${sentTs})` : base }]

package/dist/{persistent-session-ENQXJNBJ.js → persistent-session-4UG3S54C.js}

@@ -36,7 +36,7 @@ import {
   writeDirectChatSessionState,
   writeEgressAllowlist,
   writePersistentClaudeWrapper
-} from "./chunk-J2WYEOBH.js";
+} from "./chunk-J6QDPXGS.js";
 import "./chunk-XWVM4KPK.js";
 export {
   EGRESS_BASELINE_DOMAINS,
@@ -77,4 +77,4 @@ export {
   writeEgressAllowlist,
   writePersistentClaudeWrapper
 };
-//# sourceMappingURL=persistent-session-ENQXJNBJ.js.map
+//# sourceMappingURL=persistent-session-4UG3S54C.js.map

package/dist/{responsiveness-probe-46XFHCPY.js → responsiveness-probe-TK47IXPX.js}

@@ -1,6 +1,6 @@
 import {
   paneLogPath
-} from "./chunk-J2WYEOBH.js";
+} from "./chunk-J6QDPXGS.js";
 import "./chunk-XWVM4KPK.js";
 
 // src/lib/responsiveness-probe.ts
@@ -437,4 +437,4 @@ export {
   readAndResetSlackReplyBindingClassifications,
   readAndResetSlackReplyTargetClassifications
 };
-//# sourceMappingURL=responsiveness-probe-46XFHCPY.js.map
+//# sourceMappingURL=responsiveness-probe-TK47IXPX.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@integrity-labs/agt-cli",
-  "version": "0.28.337",
+  "version": "0.28.339",
   "description": "Augmented Team CLI — agent provisioning and management",
   "type": "module",
   "engines": {