@integrity-labs/agt-cli 0.28.165 → 0.28.166

package/dist/bin/agt.js

@@ -37,7 +37,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-KBFXXA5U.js";
+} from "../chunk-HWVCQ6PC.js";
 import {
   CHANNEL_REGISTRY,
   DEFAULT_FRAMEWORK,
@@ -4778,7 +4778,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.28.165" : "dev";
+var cliVersion = true ? "0.28.166" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -5792,7 +5792,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.165" : "dev";
+var cliVersion2 = true ? "0.28.166" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-KBFXXA5U.js → chunk-HWVCQ6PC.js}

@@ -7948,7 +7948,7 @@ function requireHost() {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.165" : "dev";
+var agtCliVersion = true ? "0.28.166" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -9253,4 +9253,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-KBFXXA5U.js.map
+//# sourceMappingURL=chunk-HWVCQ6PC.js.map

package/dist/lib/manager-worker.js

@@ -28,7 +28,7 @@ import {
   requireHost,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-KBFXXA5U.js";
+} from "../chunk-HWVCQ6PC.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -6878,7 +6878,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.165" : "dev";
+var agtCliVersion = true ? "0.28.166" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();

package/dist/mcp/slack-channel.js

@@ -15035,6 +15035,141 @@ function buildAgentConfigReport(opts) {
   return lines.join("\n");
 }
 
+// src/agent-status-report.ts
+var STATUS_REPORT_SCHEMA_VERSION = 1;
+var FRESHNESS_VALUES = /* @__PURE__ */ new Set(["cached", "live", "unknown"]);
+var LEVEL_VALUES = /* @__PURE__ */ new Set(["ok", "degraded", "down", "error", "unknown"]);
+function coerceLevel(value) {
+  return typeof value === "string" && LEVEL_VALUES.has(value) ? value : "unknown";
+}
+function coerceFreshness(value) {
+  return typeof value === "string" && FRESHNESS_VALUES.has(value) ? value : "unknown";
+}
+function coerceCheckedAt(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function parseAgentStatusReport(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  if (!Array.isArray(obj.channels) || !Array.isArray(obj.integrations)) return null;
+  const channels = obj.channels.filter((c) => !!c && typeof c === "object").map((c) => ({
+    channel_id: typeof c.channel_id === "string" ? c.channel_id : "unknown",
+    level: coerceLevel(c.level),
+    freshness: coerceFreshness(c.freshness),
+    checked_at: coerceCheckedAt(c.checked_at),
+    ...typeof c.reason === "string" && c.reason ? { reason: c.reason } : {}
+  }));
+  const integrations = obj.integrations.filter((i) => !!i && typeof i === "object").map((i) => ({
+    id: typeof i.id === "string" ? i.id : "unknown",
+    definition_id: typeof i.definition_id === "string" ? i.definition_id : "unknown",
+    display_name: typeof i.display_name === "string" && i.display_name ? i.display_name : typeof i.definition_id === "string" ? i.definition_id : "unknown",
+    scope: i.scope === "team" || i.scope === "organization" ? i.scope : "agent",
+    level: coerceLevel(i.level),
+    freshness: coerceFreshness(i.freshness),
+    checked_at: coerceCheckedAt(i.checked_at),
+    ...typeof i.consecutive_failures === "number" ? { consecutive_failures: i.consecutive_failures } : {},
+    ...typeof i.reason === "string" && i.reason ? { reason: i.reason } : {}
+  }));
+  return {
+    schema_version: typeof obj.schema_version === "number" ? obj.schema_version : 0,
+    agent_id: typeof obj.agent_id === "string" ? obj.agent_id : "",
+    generated_at: typeof obj.generated_at === "string" ? obj.generated_at : "",
+    manager_last_seen: coerceCheckedAt(obj.manager_last_seen),
+    channels,
+    integrations
+  };
+}
+function mergeOwnChannelLiveStatus(report, channelId, live) {
+  const liveEntry = {
+    channel_id: channelId,
+    level: live.level,
+    freshness: "live",
+    checked_at: live.checked_at,
+    ...live.reason ? { reason: live.reason } : {}
+  };
+  const existingIndex = report.channels.findIndex((ch) => ch.channel_id === channelId);
+  const channels = existingIndex === -1 ? [...report.channels, liveEntry] : report.channels.map((ch, i) => i === existingIndex ? liveEntry : ch);
+  return { ...report, channels };
+}
+function statusLevelGlyph(level) {
+  switch (level) {
+    case "ok":
+      return "\u{1F7E2}";
+    case "degraded":
+      return "\u{1F7E1}";
+    case "down":
+    case "error":
+      return "\u{1F534}";
+    default:
+      return "\u26AA";
+  }
+}
+function formatStatusAge(checkedAt, nowMs) {
+  if (!checkedAt) return "never";
+  const t = Date.parse(checkedAt);
+  if (Number.isNaN(t)) return "unknown";
+  const diffMs = nowMs - t;
+  if (diffMs < 45e3) return "just now";
+  const mins = Math.round(diffMs / 6e4);
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.round(diffMs / 36e5);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.round(diffMs / 864e5);
+  return `${days}d ago`;
+}
+
+// src/slack-status-render.ts
+var FRESHNESS_LABEL = {
+  live: "live",
+  cached: "cached",
+  unknown: "unknown"
+};
+function freshnessLabel(freshness) {
+  return FRESHNESS_LABEL[freshness] ?? freshness;
+}
+function renderChannelLine(ch, nowMs) {
+  const glyph = statusLevelGlyph(ch.level);
+  const fresh = freshnessLabel(ch.freshness);
+  const age = formatStatusAge(ch.checked_at, nowMs);
+  const detail = ch.level !== "ok" && ch.reason ? ` (${ch.reason})` : "";
+  return `${glyph} \`${ch.channel_id}\` \xB7 ${ch.level} \xB7 ${fresh} \xB7 ${age}${detail}`;
+}
+function renderIntegrationLine(it, nowMs) {
+  const glyph = statusLevelGlyph(it.level);
+  const fresh = freshnessLabel(it.freshness);
+  const age = formatStatusAge(it.checked_at, nowMs);
+  const bits = [];
+  if (it.level !== "ok" && it.reason) bits.push(it.reason);
+  if (typeof it.consecutive_failures === "number" && it.consecutive_failures > 0) {
+    bits.push(`${it.consecutive_failures} fail${it.consecutive_failures === 1 ? "" : "s"}`);
+  }
+  const detail = bits.length ? ` (${bits.join(", ")})` : "";
+  return `${glyph} \`${it.display_name}\` \xB7 ${it.level} \xB7 ${fresh} \xB7 ${age}${detail}`;
+}
+function renderSlackStatusSections(report, opts) {
+  const { probing, nowMs } = opts;
+  const lines = [];
+  lines.push(probing ? "*Channels* (probing...)" : "*Channels*");
+  if (report.channels.length === 0) {
+    lines.push("_No channels configured._");
+  } else {
+    for (const ch of report.channels) lines.push(renderChannelLine(ch, nowMs));
+  }
+  lines.push("");
+  lines.push("*Integrations*");
+  if (report.integrations.length === 0) {
+    lines.push("_No integrations configured._");
+  } else {
+    for (const it of report.integrations) lines.push(renderIntegrationLine(it, nowMs));
+  }
+  lines.push("");
+  const seen = report.manager_last_seen ? `Manager last seen ${formatStatusAge(report.manager_last_seen, nowMs)}` : "Manager has never checked in";
+  const tail = probing ? "Integration health is cached; confirming this channel's own status..." : "Integration health is cached from the last probe.";
+  const skew = report.schema_version !== STATUS_REPORT_SCHEMA_VERSION ? ` (report schema v${report.schema_version}; update this agent for full detail)` : "";
+  lines.push(`_${seen}. ${tail}${skew}_`);
+  return lines.join("\n");
+}
+
 // src/pane-tail.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -18352,7 +18487,7 @@ function buildSlackHelpMessage(codeName) {
     `\u2022 \`${agentSlashCommand("/restart")}\` \u2014 restart this agent`,
     `\u2022 \`${agentSlashCommand("/onboard")}\` \u2014 re-run this agent's onboarding: re-interview, existing config kept (allowlisted users)`,
     `\u2022 \`${agentSlashCommand("/resume-onboarding")}\` \u2014 resume this agent's onboarding where it left off (allowlisted users)`,
-    `\u2022 \`${agentSlashCommand("/status")}\` \u2014 this agent's model, session origin, uptime + connectivity`,
+    `\u2022 \`${agentSlashCommand("/status")}\` - full health report: model, session, uptime + per-channel and per-integration status (cached snapshot, then this channel's own live check)`,
     `\u2022 \`${agentSlashCommand("/ping")}\` - confirm this agent's channel is connected: posts a visible pong (team + manager only)`,
     "\u2022 `/watch <google-doc-url> [duration]` (type it in chat) \u2014 watch a Google Doc for comments that mention me (default 2h, max 7d; auto-pauses when the window ends). In a shared channel, address me as `/watch-<my-name>`.",
     "\u2022 `/kill` \u2014 silence all agents in this thread for 6h (use as a thread reply)",
@@ -18443,17 +18578,101 @@ function buildAgentStatusReply(codeName) {
   const sessionState = readAgentSessionState(SLACK_AGENT_DIR);
   return buildAgentConfigReport({ codeName, connectivityLine, state: sessionState });
 }
-async function postEphemeralViaResponseUrl(responseUrl, text, logTag) {
+var SLACK_OWN_CHANNEL_ID = "slack";
+function statusRuntimeConfig() {
+  if (!AGT_HOST || !AGT_API_KEY || !AGT_AGENT_ID) return null;
+  return { apiHost: AGT_HOST, apiKey: AGT_API_KEY, agentId: AGT_AGENT_ID };
+}
+async function computeSlackOwnChannelLiveStatus() {
+  const checked_at = (/* @__PURE__ */ new Date()).toISOString();
+  const connected = currentWs != null && !isShuttingDown;
+  if (!connected) {
+    return { level: "down", checked_at, reason: "Socket Mode disconnected" };
+  }
+  const { id, authFailed } = await getBotUserId();
+  if (id) {
+    return { level: "ok", checked_at, reason: "Socket Mode connected, auth.test ok" };
+  }
+  if (authFailed) {
+    return { level: "error", checked_at, reason: "auth.test failed (token invalid)" };
+  }
+  return { level: "degraded", checked_at, reason: "Socket Mode connected, auth.test inconclusive" };
+}
+async function handleStatusCommand(responseUrl, codeName) {
+  const configBlock = buildAgentStatusReply(codeName);
+  const cfg = statusRuntimeConfig();
+  let report = null;
+  if (cfg) {
+    try {
+      const { apiCall: apiCall2 } = await Promise.resolve().then(() => (init_ask_user_runtime(), ask_user_runtime_exports));
+      const res = await apiCall2(
+        cfg,
+        "GET",
+        `/host/status?agent_id=${encodeURIComponent(cfg.agentId)}`
+      );
+      if (res.ok) {
+        report = parseAgentStatusReport(await res.json());
+      } else {
+        process.stderr.write(
+          `slack-channel(${codeName}): /status host fetch returned ${res.status}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `slack-channel(${codeName}): /status host fetch failed: ${err.message}
+`
+      );
+    }
+  }
+  if (!report) {
+    await postEphemeralViaResponseUrl(
+      responseUrl,
+      `${configBlock}
+
+_Channel + integration health is unavailable right now (host unreachable). Try again shortly._`,
+      codeName
+    );
+    return;
+  }
+  const snapshot = `${configBlock}
+
+${renderSlackStatusSections(report, {
+    probing: true,
+    nowMs: Date.now()
+  })}`;
+  await postEphemeralViaResponseUrl(responseUrl, snapshot, codeName);
+  const live = await computeSlackOwnChannelLiveStatus();
+  const merged = mergeOwnChannelLiveStatus(report, SLACK_OWN_CHANNEL_ID, live);
+  const finalReport = `${configBlock}
+
+${renderSlackStatusSections(merged, {
+    probing: false,
+    nowMs: Date.now()
+  })}`;
+  await postEphemeralViaResponseUrl(responseUrl, finalReport, codeName, { replaceOriginal: true });
+}
+async function postEphemeralViaResponseUrl(responseUrl, text, logTag, opts = {}) {
   try {
-    await fetch(responseUrl, {
+    const res = await fetch(responseUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json; charset=utf-8" },
-      body: JSON.stringify({ response_type: "ephemeral", text }),
+      body: JSON.stringify({
+        response_type: "ephemeral",
+        text,
+        ...opts.replaceOriginal ? { replace_original: true } : {}
+      }),
       // Match the rest of the Slack API call sites in this file. Without
       // this, a hung response_url request can stall the live Socket Mode
       // event loop indefinitely (CodeRabbit feedback on PR #578).
       signal: AbortSignal.timeout(SLACK_DOWNLOAD_TIMEOUT_MS)
     });
+    if (!res.ok) {
+      process.stderr.write(
+        `slack-channel(${logTag}): response_url POST returned ${res.status}
+`
+      );
+    }
   } catch (err) {
     process.stderr.write(
       `slack-channel(${logTag}): response_url POST failed: ${err.message}
@@ -18701,7 +18920,7 @@ async function handleSlashCommandEnvelope(payload) {
   const codeName = AGENT_CODE_NAME ?? "unknown";
   if (!command || !responseUrl) return;
   if (matchesAgentCommand(command, "/status") || matchesAgentCommand(command, "/agent-status")) {
-    await postEphemeralViaResponseUrl(responseUrl, buildAgentStatusReply(codeName), codeName);
+    await handleStatusCommand(responseUrl, codeName);
     return;
   }
   if (matchesAgentCommand(command, "/help")) {

package/package.json

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