@integrity-labs/agt-cli 0.28.327 → 0.28.329

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

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

package/dist/lib/manager-worker.js

@@ -43,7 +43,7 @@ import {
   requireHost,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-EQMRT6OT.js";
+} from "../chunk-AOSBSVNB.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -132,7 +132,7 @@ import {
   takeZombieDetection,
   transcriptActivityAgeSeconds,
   writeEgressAllowlist
-} from "../chunk-BSTFCC62.js";
+} from "../chunk-J2WYEOBH.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
@@ -8386,7 +8386,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.327" : "dev";
+var agtCliVersion = true ? "0.28.329" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -9282,7 +9282,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-BICDYHOC.js");
+      const { collectDiagnostics } = await import("../persistent-session-ENQXJNBJ.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames)
@@ -9381,7 +9381,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-BICDYHOC.js");
+      const { collectDiagnostics } = await import("../persistent-session-ENQXJNBJ.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -9530,7 +9530,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-FEAFPNUF.js");
+      } = await import("../responsiveness-probe-OJJESVVX.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -9562,7 +9562,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-FEAFPNUF.js");
+        } = await import("../responsiveness-probe-OJJESVVX.js");
         const { getProjectDir: wedgeProjectDir } = await import("../claude-scheduler-FATCLHDM.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -12660,7 +12660,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-BICDYHOC.js");
+        const { collectDiagnostics } = await import("../persistent-session-ENQXJNBJ.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName])
@@ -12710,7 +12710,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-BICDYHOC.js");
+      const { collectDiagnostics } = await import("../persistent-session-ENQXJNBJ.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName])
@@ -13208,7 +13208,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-BOFTEAQC.js");
+  } = await import("../claude-pair-runtime-T7EFAWS5.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/direct-chat-channel.js

@@ -14255,6 +14255,129 @@ function writeTurnInitiatorMarker(input) {
   }
 }
 
+// src/direct-chat-pending-inbound.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  renameSync as renameSync2,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join3 } from "path";
+function hexEncodeSegment(value) {
+  return Buffer.from(value, "utf8").toString("hex");
+}
+function directChatMarkerName(sessionId, messageId) {
+  return `${hexEncodeSegment(sessionId)}__${hexEncodeSegment(messageId)}.json`;
+}
+var defaultClearMarkerFile = (fullPath) => {
+  try {
+    if (existsSync2(fullPath)) unlinkSync(fullPath);
+  } catch {
+  }
+};
+function directChatInboundId(sessionId, messageId) {
+  return `direct-chat|${sessionId.length}|${sessionId}|${messageId}`;
+}
+function writeDirectChatPendingInboundMarker(dir, sessionId, messageId) {
+  if (!dir || !sessionId || !messageId) return;
+  try {
+    mkdirSync2(dir, { recursive: true });
+    const marker = {
+      channel: "direct-chat",
+      session_id: sessionId,
+      message_id: messageId,
+      received_at: (/* @__PURE__ */ new Date()).toISOString(),
+      inbound_id: directChatInboundId(sessionId, messageId)
+    };
+    const final = join3(dir, directChatMarkerName(sessionId, messageId));
+    const tmp = `${final}.tmp`;
+    writeFileSync2(tmp, JSON.stringify(marker), "utf8");
+    renameSync2(tmp, final);
+  } catch {
+  }
+}
+function clearDirectChatPendingMarkersForSession(dir, sessionId, op = defaultClearMarkerFile) {
+  if (!dir || !sessionId) return 0;
+  const prefix = `${hexEncodeSegment(sessionId)}__`;
+  let cleared = 0;
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return 0;
+  }
+  for (const name of names) {
+    if (!name.startsWith(prefix) || !name.endsWith(".json")) continue;
+    op(join3(dir, name));
+    cleared += 1;
+  }
+  return cleared;
+}
+
+// src/direct-chat-recovery-outbox.ts
+async function consumeDirectChatRecoveryFile(fullPath, filename, deps) {
+  if (filename.endsWith(".tmp") || filename.endsWith(".poison")) return "skipped";
+  let payload;
+  try {
+    payload = JSON.parse(deps.readFile(fullPath));
+  } catch (err) {
+    deps.log(`recovery outbox parse failed (${filename}): ${err.message}`);
+    try {
+      deps.renameFile(fullPath, `${fullPath}.parse-error.poison`);
+    } catch {
+    }
+    return "poison";
+  }
+  if (!payload || !payload.session_id || !payload.text) {
+    deps.log(`recovery outbox malformed (${filename}): missing session_id or text`);
+    if (payload && payload.marker_name) {
+      try {
+        deps.removeLedgerEntry(payload.marker_name);
+      } catch {
+      }
+    }
+    try {
+      deps.renameFile(fullPath, `${fullPath}.malformed.poison`);
+    } catch {
+    }
+    return "poison";
+  }
+  const content = deps.sanitize(payload.text);
+  const messageIds = deps.peekClaims(payload.session_id);
+  let result;
+  try {
+    result = await deps.deliver({
+      sessionId: payload.session_id,
+      content,
+      messageIds
+    });
+  } catch (err) {
+    result = { ok: false, error: err.message };
+  }
+  if (result.ok && !result.error) {
+    deps.clearClaims(payload.session_id, messageIds);
+    deps.clearMarkers(payload.session_id);
+    if (payload.marker_name) deps.removeLedgerEntry(payload.marker_name);
+    try {
+      deps.unlinkFile(fullPath);
+    } catch {
+    }
+    deps.log(`ghost-reply recovery sent (session=${payload.session_id})`);
+    return "delivered";
+  }
+  if (payload.marker_name) deps.removeLedgerEntry(payload.marker_name);
+  try {
+    deps.unlinkFile(fullPath);
+  } catch {
+  }
+  deps.log(
+    `ghost-reply recovery send failed (session=${payload.session_id}): ${result.error ?? "unknown"} - re-armed for retry`
+  );
+  return "failed";
+}
+
 // src/direct-chat-poll-guard.ts
 function evaluatePollGuard(state, nowMs, stuckMs) {
   if (!state.inFlight) return { run: true, stuck: false };
@@ -14277,14 +14400,14 @@ async function fetchWithTimeout(input, init, timeoutMs, fetchImpl = fetch) {
 
 // src/mcp-spawn-lock.ts
 import {
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
   readFileSync as readFileSync3,
-  renameSync as renameSync2,
-  unlinkSync,
-  writeFileSync as writeFileSync2
+  renameSync as renameSync3,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function defaultIsPidAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   try {
@@ -14302,7 +14425,7 @@ function acquireMcpSpawnLock(args) {
   const isPidAlive = options.isPidAlive ?? defaultIsPidAlive;
   const selfPid = options.selfPid ?? process.pid;
   const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const path = join3(agentDir, basename);
+  const path = join4(agentDir, basename);
   const existing = readLockHolder(path);
   if (existing) {
     if (existing.pid === selfPid) {
@@ -14312,11 +14435,11 @@ function acquireMcpSpawnLock(args) {
       return { kind: "blocked", path, holder: existing };
     }
   }
-  mkdirSync2(agentDir, { recursive: true, mode: 448 });
+  mkdirSync3(agentDir, { recursive: true, mode: 448 });
   const tmpPath = `${path}.${selfPid}.tmp`;
   const payload = { pid: selfPid, started_at: now() };
-  writeFileSync2(tmpPath, JSON.stringify(payload), { mode: 384 });
-  renameSync2(tmpPath, path);
+  writeFileSync3(tmpPath, JSON.stringify(payload), { mode: 384 });
+  renameSync3(tmpPath, path);
   return { kind: "acquired", path };
 }
 function releaseMcpSpawnLock(lockPath, opts = {}) {
@@ -14326,12 +14449,12 @@ function releaseMcpSpawnLock(lockPath, opts = {}) {
   if (!existing) return;
   if (existing.pid !== selfPid) return;
   try {
-    unlinkSync(lockPath);
+    unlinkSync2(lockPath);
   } catch {
   }
 }
 function readLockHolder(path) {
-  if (!existsSync2(path)) return null;
+  if (!existsSync3(path)) return null;
   try {
     const raw = readFileSync3(path, "utf8");
     const parsed = JSON.parse(raw);
@@ -14346,35 +14469,36 @@ function readLockHolder(path) {
 
 // src/direct-chat-channel.ts
 import { homedir as homedir2 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { randomUUID } from "crypto";
 import {
   watch,
-  mkdirSync as mkdirSync3,
-  writeFileSync as writeFileSync3,
+  mkdirSync as mkdirSync4,
+  writeFileSync as writeFileSync4,
   readFileSync as readFileSync5,
-  existsSync as existsSync4,
-  renameSync as renameSync3,
-  unlinkSync as unlinkSync2
+  readdirSync as readdirSync2,
+  existsSync as existsSync5,
+  renameSync as renameSync4,
+  unlinkSync as unlinkSync3
 } from "fs";
 
 // src/direct-chat-inbound-attachments.ts
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
 var MAX_INBOUND_ATTACHMENT_BYTES = 10 * 1024 * 1024;
 var INBOUND_ATTACHMENTS_SUBDIR = "direct-chat-inbound";
 function resolveInboundAttachmentsDir(input) {
   const { codeName, turnInitiatorFile, agentId, homeDir } = input;
   const codeNameTrimmed = typeof codeName === "string" ? codeName.trim() : "";
   if (codeNameTrimmed) {
-    return join4(homeDir, ".augmented", codeNameTrimmed, INBOUND_ATTACHMENTS_SUBDIR);
+    return join5(homeDir, ".augmented", codeNameTrimmed, INBOUND_ATTACHMENTS_SUBDIR);
   }
   const initiator = typeof turnInitiatorFile === "string" ? turnInitiatorFile.trim() : "";
   if (initiator) {
-    return join4(dirname2(initiator), INBOUND_ATTACHMENTS_SUBDIR);
+    return join5(dirname2(initiator), INBOUND_ATTACHMENTS_SUBDIR);
   }
   const agentIdTrimmed = typeof agentId === "string" ? agentId.trim() : "";
   if (agentIdTrimmed) {
-    return join4(homeDir, ".augmented", agentIdTrimmed, INBOUND_ATTACHMENTS_SUBDIR);
+    return join5(homeDir, ".augmented", agentIdTrimmed, INBOUND_ATTACHMENTS_SUBDIR);
   }
   return null;
 }
@@ -14472,11 +14596,11 @@ async function downloadInboundAttachments(attachments, dir, deps) {
 }
 
 // src/flags-cache-read.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import { homedir } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function defaultFlagsCachePath() {
-  return join5(homedir(), ".augmented", "flags-cache.json");
+  return join6(homedir(), ".augmented", "flags-cache.json");
 }
 function envBoolean(raw) {
   if (raw === void 0) return void 0;
@@ -14488,7 +14612,7 @@ function envBoolean(raw) {
 }
 function cachedBoolean(key, path) {
   try {
-    if (!existsSync3(path)) return void 0;
+    if (!existsSync4(path)) return void 0;
     const parsed = JSON.parse(readFileSync4(path, "utf8"));
     if (!parsed || typeof parsed !== "object") return void 0;
     const flags = parsed.flags;
@@ -14826,7 +14950,7 @@ var DIRECT_CHAT_MAINTENANCE_COOLDOWN_MS = (() => {
 var AGT_HOST = process.env.AGT_HOST;
 var AGT_API_KEY = process.env.AGT_API_KEY;
 var AGT_AGENT_ID = process.env.AGT_AGENT_ID;
-var DIRECT_CHAT_AGENT_DIR = AGT_AGENT_ID ? join6(homedir2(), ".augmented", AGT_AGENT_ID) : null;
+var DIRECT_CHAT_AGENT_DIR = AGT_AGENT_ID ? join7(homedir2(), ".augmented", AGT_AGENT_ID) : null;
 var INBOUND_ATTACHMENTS_DIR = resolveInboundAttachmentsDir({
   codeName: process.env.AGT_AGENT_CODE_NAME,
   turnInitiatorFile: process.env.AGT_TURN_INITIATOR_FILE,
@@ -14834,7 +14958,10 @@ var INBOUND_ATTACHMENTS_DIR = resolveInboundAttachmentsDir({
   homeDir: homedir2()
 });
 var AGT_AGENT_CODE_NAME = process.env.AGT_AGENT_CODE_NAME;
-var PROGRESS_HEARTBEAT_PATH = AGT_AGENT_CODE_NAME ? join6(homedir2(), ".augmented", AGT_AGENT_CODE_NAME, "channel-progress-heartbeat.json") : null;
+var PROGRESS_HEARTBEAT_PATH = AGT_AGENT_CODE_NAME ? join7(homedir2(), ".augmented", AGT_AGENT_CODE_NAME, "channel-progress-heartbeat.json") : null;
+var DIRECT_CHAT_PENDING_INBOUND_DIR = AGT_AGENT_CODE_NAME ? join7(homedir2(), ".augmented", AGT_AGENT_CODE_NAME, "direct-chat-pending-inbound") : null;
+var DIRECT_CHAT_RECOVERY_OUTBOX_DIR = AGT_AGENT_CODE_NAME ? join7(homedir2(), ".augmented", AGT_AGENT_CODE_NAME, "direct-chat-recovery-outbox") : null;
+var DIRECT_CHAT_RECOVERY_LEDGER_DIR = AGT_AGENT_CODE_NAME ? join7(homedir2(), ".augmented", AGT_AGENT_CODE_NAME, ".agt-direct-chat-recovery-ledger") : null;
 var progressReceivedAt = /* @__PURE__ */ new Map();
 var directChatProgressState = { tracked: null };
 var directChatProgressTickRunning = false;
@@ -14851,7 +14978,7 @@ var directChatKanbanCardClient = createKanbanCardActiveClient({
 `)
 });
 function readProgressHeartbeat() {
-  if (!PROGRESS_HEARTBEAT_PATH || !existsSync4(PROGRESS_HEARTBEAT_PATH)) return null;
+  if (!PROGRESS_HEARTBEAT_PATH || !existsSync5(PROGRESS_HEARTBEAT_PATH)) return null;
   try {
     return parseProgressHeartbeat(readFileSync5(PROGRESS_HEARTBEAT_PATH, "utf-8"));
   } catch {
@@ -14862,12 +14989,12 @@ function seedProgressHeartbeat() {
   if (!PROGRESS_HEARTBEAT_PATH) return;
   const tmp = `${PROGRESS_HEARTBEAT_PATH}.${process.pid}.tmp`;
   try {
-    mkdirSync3(join6(homedir2(), ".augmented", AGT_AGENT_CODE_NAME), { recursive: true });
-    writeFileSync3(tmp, serializeProgressHeartbeat(SEED_PROGRESS_STEP, Date.now()), { mode: 384 });
-    renameSync3(tmp, PROGRESS_HEARTBEAT_PATH);
+    mkdirSync4(join7(homedir2(), ".augmented", AGT_AGENT_CODE_NAME), { recursive: true });
+    writeFileSync4(tmp, serializeProgressHeartbeat(SEED_PROGRESS_STEP, Date.now()), { mode: 384 });
+    renameSync4(tmp, PROGRESS_HEARTBEAT_PATH);
   } catch {
     try {
-      unlinkSync2(tmp);
+      unlinkSync3(tmp);
     } catch {
     }
   }
@@ -15020,9 +15147,9 @@ var inboundAttachmentDeps = {
       bytes: async () => new Uint8Array(await res.arrayBuffer())
     };
   },
-  ensureDir: (dir) => mkdirSync3(dir, { recursive: true }),
-  writeFile: (path, bytes) => writeFileSync3(path, bytes, { mode: 384 }),
-  joinPath: (...parts) => join6(...parts),
+  ensureDir: (dir) => mkdirSync4(dir, { recursive: true }),
+  writeFile: (path, bytes) => writeFileSync4(path, bytes, { mode: 384 }),
+  joinPath: (...parts) => join7(...parts),
   warn: (msg) => process.stderr.write(`${msg}
 `)
 };
@@ -15190,6 +15317,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
           };
         }
         claimTracker.clear(session_id, message_ids);
+        clearDirectChatPendingMarkersForSession(DIRECT_CHAT_PENDING_INBOUND_DIR, session_id);
         const messageId = data.message_id;
         for (let i = 1; i < slices.length; i++) {
           await sleep(STREAM_REPLY_FLUSH_MS);
@@ -15234,6 +15362,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         };
       }
       claimTracker.clear(session_id, message_ids);
+      clearDirectChatPendingMarkersForSession(DIRECT_CHAT_PENDING_INBOUND_DIR, session_id);
       return { content: [{ type: "text", text: "sent" }] };
     } catch (err) {
       return {
@@ -15262,6 +15391,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         };
       }
       claimTracker.clear(session_id, message_ids);
+      clearDirectChatPendingMarkersForSession(DIRECT_CHAT_PENDING_INBOUND_DIR, session_id);
       return { content: [{ type: "text", text: "consumed" }] };
     } catch (err) {
       return {
@@ -15361,6 +15491,13 @@ async function pollForMessages(sinceMs) {
           }
         }
       });
+      if (!isNotice) {
+        writeDirectChatPendingInboundMarker(
+          DIRECT_CHAT_PENDING_INBOUND_DIR,
+          msg.session_id,
+          msg.id
+        );
+      }
       if (!isNotice && msg.sender_id) {
         writeTurnInitiatorMarker({
           channel: "direct-chat",
@@ -15450,7 +15587,7 @@ var doorbellWatcher = null;
 var safetyNetTimer = null;
 if (DOORBELL_ENABLED && DIRECT_CHAT_AGENT_DIR) {
   try {
-    mkdirSync3(DIRECT_CHAT_AGENT_DIR, { recursive: true });
+    mkdirSync4(DIRECT_CHAT_AGENT_DIR, { recursive: true });
   } catch {
   }
   const sessionState = readDirectChatSessionState(DIRECT_CHAT_AGENT_DIR, Date.now());
@@ -15494,6 +15631,106 @@ if (PROGRESS_HEARTBEAT_PATH) {
   }, PROGRESS_TICK_MS);
   progressTickTimer.unref?.();
 }
+function sanitizeRecoveryText(text) {
+  const preamble = stripRepostPreambleWithMeta(text);
+  if (preamble.stripped) emitPreambleStripTelemetry("direct_chat", preamble.shape);
+  const guarded = redactToolCallMarkup(preamble.text);
+  if (guarded.redacted) emitToolCallMarkupRedactionTelemetry("direct_chat");
+  const apiErr = rewriteTransientApiError(guarded.text);
+  if (apiErr.rewritten) emitTransientApiErrorTelemetry("direct_chat", apiErr.match, apiErr.original);
+  return apiErr.text;
+}
+function directChatRecoveryDeps() {
+  return {
+    readFile: (p) => readFileSync5(p, "utf-8"),
+    renameFile: (from, to) => renameSync4(from, to),
+    unlinkFile: (p) => {
+      if (existsSync5(p)) unlinkSync3(p);
+    },
+    sanitize: sanitizeRecoveryText,
+    peekClaims: (sessionId) => claimTracker.peek(sessionId),
+    clearClaims: (sessionId, ids) => claimTracker.clear(sessionId, ids),
+    clearMarkers: (sessionId) => clearDirectChatPendingMarkersForSession(DIRECT_CHAT_PENDING_INBOUND_DIR, sessionId),
+    removeLedgerEntry: (markerName) => {
+      if (!DIRECT_CHAT_RECOVERY_LEDGER_DIR) return;
+      if (markerName.includes("/") || markerName.includes("\\") || markerName.includes("..")) return;
+      try {
+        const p = join7(DIRECT_CHAT_RECOVERY_LEDGER_DIR, markerName);
+        if (existsSync5(p)) unlinkSync3(p);
+      } catch {
+      }
+    },
+    deliver: async ({ sessionId, content, messageIds }) => {
+      try {
+        const res = await apiPost("/host/direct-chat/reply", {
+          agent_id: AGT_AGENT_ID,
+          session_id: sessionId,
+          content,
+          message_ids: messageIds
+        });
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok || data.error) return { ok: false, error: data.error ?? `HTTP ${res.status}` };
+        return { ok: true };
+      } catch (err) {
+        return { ok: false, error: err.message };
+      }
+    },
+    log: (line) => process.stderr.write(`direct-chat-channel(${AGT_AGENT_CODE_NAME}): ${line}
+`)
+  };
+}
+var directChatRecoveryInFlight = /* @__PURE__ */ new Set();
+async function processDirectChatRecoveryOutboxFile(filename) {
+  if (!DIRECT_CHAT_RECOVERY_OUTBOX_DIR) return;
+  if (directChatRecoveryInFlight.has(filename)) return;
+  const enabled = resolveHostBooleanFlag({
+    key: "direct-chat-recovery",
+    envVar: "AGT_DIRECT_CHAT_RECOVERY_ENABLED",
+    defaultValue: false
+  });
+  if (!enabled) return;
+  directChatRecoveryInFlight.add(filename);
+  try {
+    const fullPath = join7(DIRECT_CHAT_RECOVERY_OUTBOX_DIR, filename);
+    await consumeDirectChatRecoveryFile(fullPath, filename, directChatRecoveryDeps());
+  } catch (err) {
+    process.stderr.write(
+      `direct-chat-channel(${AGT_AGENT_CODE_NAME}): recovery consume failed (${filename}): ${err.message}
+`
+    );
+  } finally {
+    directChatRecoveryInFlight.delete(filename);
+  }
+}
+var directChatRecoveryWatcher = null;
+if (DIRECT_CHAT_RECOVERY_OUTBOX_DIR) {
+  try {
+    mkdirSync4(DIRECT_CHAT_RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
+  } catch {
+  }
+  try {
+    for (const f of readdirSync2(DIRECT_CHAT_RECOVERY_OUTBOX_DIR)) {
+      if (f.endsWith(".json")) void processDirectChatRecoveryOutboxFile(f);
+    }
+  } catch {
+  }
+  try {
+    directChatRecoveryWatcher = watch(DIRECT_CHAT_RECOVERY_OUTBOX_DIR, (_event, filename) => {
+      if (!filename) return;
+      const name = filename.toString();
+      if (!name.endsWith(".json")) return;
+      if (existsSync5(join7(DIRECT_CHAT_RECOVERY_OUTBOX_DIR, name))) {
+        void processDirectChatRecoveryOutboxFile(name);
+      }
+    });
+    directChatRecoveryWatcher.unref?.();
+  } catch (err) {
+    process.stderr.write(
+      `direct-chat-channel(${AGT_AGENT_CODE_NAME}): recovery watcher failed (${err.message})
+`
+    );
+  }
+}
 var isShuttingDown = false;
 function shutdown(reason) {
   if (isShuttingDown) return;

package/dist/mcp/origami.js

@@ -39592,7 +39592,8 @@ var WAITING_KINDS = [
   "pr-merged",
   "human",
   "external",
-  "other"
+  "other",
+  "approval"
 ];
 var WAITING_KIND_SET = new Set(WAITING_KINDS);
 
@@ -39985,6 +39986,16 @@ var FLAG_REGISTRY = [
     defaultValue: false,
     envVar: "AGT_LIVE_STREAM_PRODUCER_ENABLED"
   },
+  {
+    key: "auto-provision-agt-live",
+    description: "Auto-provision the Augmented Live integration (free tier, watermarked) into every NEW organization as an org-scoped install (ENG-7819). Consumed in TWO places: the seed_default_live_integration AFTER INSERT trigger on organizations reads the EXPLICIT feature_flags row (a plpgsql trigger cannot see this compiled default, so dark = no row = trigger no-ops; flipping the flag on this page writes the row the trigger reads - GLOBAL value only, per-org overrides are not consulted by the trigger), and the POST /organizations route evaluates it normally to send the owner provisioning notice. Restricted-posture orgs are skipped; opt-out (remove/block) is permanent - no reconciler. Boolean gate; ships dark. Pre-flip gates: docs/operator/default-integrations-admission.md.",
+    flagType: "boolean",
+    defaultValue: false,
+    // Grants every new open org a public-publishing capability by default;
+    // flipping it on is fleet-shaping and worth an explicit confirm (ADR-0022
+    // §4, same treatment as augmented-support-auto-provision).
+    sensitive: true
+  },
   {
     key: "admin-live-pane",
     description: "Live agent pane streaming on the platform-admin surfaces (ENG-6588): the agent Diagnostics tab and the /admin embed poll GET /admin/agents/:id/pane (tmux capture-pane over SSM) ~every 3s for a bounded window. Boolean gate; ships dark; when OFF the route returns feature_disabled and the UI falls back to the 30s static diagnostics snapshot. It is the no-deploy kill switch bounding the shared-SSM blast radius (SSM SendCommand throttles account-wide, shared with incident-response runbooks).",
@@ -40097,6 +40108,16 @@ var FLAG_REGISTRY = [
     // canary is a high-blast-radius change worth an explicit confirm.
     sensitive: true
   },
+  {
+    key: "direct-chat-recovery",
+    description: "Always-on direct-chat ghost-reply recovery (ENG-7814, ENG-6722 slice E). direct-chat has no recovery-outbox by default: block-turn-end (channel-block-turn-end) only makes the MODEL re-send and is dark/canary, so a direct-chat turn answered as plain text with no direct_chat.reply is lost. When ON, the ghost-reply Stop hook, for an owed and unanswered direct-chat inbound where block-turn-end did not fire, writes the last assistant text to a direct-chat-recovery-outbox that the direct-chat MCP consumes and POSTs to /host/direct-chat/reply for the session, re-sending the reply the agent produced but never delivered. session_id is unambiguous (one session per marker), so there is no cross-thread mis-correlation risk (why direct-chat can safely re-send where Slack needs the ENG-7806 ledger). Confirm-before-clear: the pending marker is cleared only after the POST confirms; a per-marker recovery ledger caps one in-flight recovery per inbound and re-arms on failure. Independent of channel-block-turn-end (either can be on). The env var AGT_DIRECT_CHAT_RECOVERY_ENABLED is the operator/host override the bash hook reads directly (materialized by the manager) and the MCP resolves via the flags cache. Boolean gate; ships dark, flip per host/org to canary before fleet rollout.",
+    flagType: "boolean",
+    defaultValue: false,
+    envVar: "AGT_DIRECT_CHAT_RECOVERY_ENABLED",
+    // Re-sends a reply on the agent behalf (a customer-visible send); flipping it
+    // beyond a canary is a blast-radius change worth an explicit confirm.
+    sensitive: true
+  },
   {
     key: "ghost-reply-intent-classifier",
     description: `Intentional-non-reply suppression on the ghost-reply RECOVERY path (ENG-7096, ENG-7478). The recovery-outbox consumer in the channel MCP only ever fires for turns where the agent ended with text but did NOT call the matching reply tool for that conversation - a set that includes DELIBERATE non-replies and internal third-person self-status narration ("Filed CS-1443... standing by"). A cheap model (the conversation-eval backend, AGT_CONV_EVAL_*) classifies the recovered text as a real message for the user (deliver) or internal not-replying / self-status narration (suppress), keyed on grammatical person, biased to DELIVER and fail-open (a classifier outage degrades to today's behaviour, never a dropped real reply). off = classifier never runs, every recovered reply is posted exactly as today (ships dark, == the old boolean-false). shadow = classify + log the would-suppress verdict for operator adjudication but STILL DELIVER (measure the suppression rate before acting). enforce = actually suppress on a clean high-confidence suppress verdict. The channel server reads this live from the heartbeat flags-cache (or the env override); enforce is a deliberate, audited per-org flip after a shadow soak.`,

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

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

package/dist/{responsiveness-probe-FEAFPNUF.js → responsiveness-probe-OJJESVVX.js}

@@ -1,6 +1,6 @@
 import {
   paneLogPath
-} from "./chunk-BSTFCC62.js";
+} from "./chunk-J2WYEOBH.js";
 import "./chunk-XWVM4KPK.js";
 
 // src/lib/responsiveness-probe.ts
@@ -427,4 +427,4 @@ export {
   readAndResetSlackReplyBindingClassifications,
   readAndResetSlackReplyTargetClassifications
 };
-//# sourceMappingURL=responsiveness-probe-FEAFPNUF.js.map
+//# sourceMappingURL=responsiveness-probe-OJJESVVX.js.map

package/package.json

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