@integrity-labs/agt-cli 0.28.39 → 0.28.41

package/dist/{chunk-AL7UJNNI.js → chunk-GBST6UWT.js}

@@ -3,6 +3,7 @@ import {
   DEFAULT_MODELS,
   OAUTH_PROVIDERS,
   coerceEnvValue,
+  expandTemplateVars,
   formatForOpenClawCli,
   getChannel,
   getFlagDefinition,
@@ -11,10 +12,17 @@ import {
   listFlagDefinitions,
   normalizeFlagValue,
   parseDeliveryTarget,
+  parseEnvIntegrations,
+  probeComposioAccount,
+  probeComposioMcpToolCall,
+  probeHttpProvider,
+  probeMcpHttp,
   registerFramework,
   resolveAvatarEnvUrl,
+  resolveConnectivityProbe,
+  worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "./chunk-X5E2Q3W2.js";
+} from "./chunk-SJUD2BWU.js";
 
 // ../../packages/core/dist/integrations/registry.js
 var INTEGRATION_REGISTRY = [
@@ -3390,54 +3398,43 @@ acknowledge before you start.
 - **FAST (< 60s):** handle inline. Reply via the channel tool
   (slack.reply / telegram.reply / directchat.reply) and end your turn.
 
-- **SLOW (\u2265 60s):** acknowledge, dispatch to a background channel worker,
-  stay responsive.
+- **SLOW (\u2265 60s):** acknowledge, dispatch to background, stay responsive.
   1. Send a one-line acknowledgement via the channel tool \u2014 short, warm,
      and tell the user you'll come back. Example shape (don't copy verbatim,
      match your voice): "On it \u2014 this'll take a minute or two, I'll ping
      when it's done."
-  2. Dispatch the work to a background \`channel-message-handler\` sub-agent:
-     the Agent tool with \`subagent_type: channel-message-handler\` AND
-     \`run_in_background: true\`. Put EVERYTHING the worker needs in the
-     dispatch prompt \u2014 the user's full request, relevant thread context,
-     which integrations/tools to use \u2014 plus the **channel-specific routing
-     keys** its reply tool needs: Slack threads \u2192 \`{ channel_id, thread_ts }\`;
-     Slack non-thread DMs \u2192 \`{ channel_id }\`; Telegram \u2192 \`{ chat_id, message_id }\`;
-     Direct Chat \u2192 \`{ conversation_id }\`. Pass these verbatim from the
-     inbound \`<channel>\` tag \u2014 don't substitute a generic \`message_ts\`,
-     since only Slack threads use it. The worker inherits your full MCP tool
-     surface but NOT your conversation context.
+  2. Dispatch the work to a background sub-agent: the Agent tool with
+     \`subagent_type: general-purpose\` AND \`run_in_background: true\`.
+     Put EVERYTHING the worker needs in the dispatch prompt \u2014 the user's
+     full request, relevant thread context, which integrations/tools to
+     use, and the exact shape of result you want back. The worker inherits
+     your full MCP tool surface but NOT your conversation context.
   3. End your turn after dispatching. This is the point: you stay free to
      answer other messages while the worker grinds. Do NOT wait, poll, or
      dispatch the same work synchronously \u2014 a synchronous dispatch blocks
      your turn and defeats the purpose.
-  4. \`channel-message-handler\` posts the substantive reply **itself**, via
-     its own channel reply tool (\`slack.reply\` / \`telegram.reply\` /
-     \`directchat.reply\`) addressed by the routing keys you passed \u2014 you do
-     NOT relay it. Its completion notification lands automatically as a
-     system message; read it just to confirm the reply went out.
-  5. If the completion notification reports a failure \u2014 or that the worker
-     could not post \u2014 post the reply (or a brief status) yourself to the
-     same thread / chat / conversation you acknowledged in step 1, and
-     either re-dispatch with a better prompt or handle it inline. Never go
-     silent.
-
-> **Why a background \`channel-message-handler\` dispatch:** two findings
-> combine into this shape. (1) ENG-6274 (2026-06-10, Claude Code 2.1.170,
-> \`docs/spikes/ENG-6274-run-in-background-dispatch.md\`): a background
-> dispatch returns immediately, your turn ends, and inbound messages get
-> answered in seconds while the worker runs \u2014 the completion arrives as a
-> notification you handle like any other turn. (2) ENG-6273 (on-host probe
-> at the fleet's pinned 2.1.170,
-> \`docs/spikes/ENG-6273-verify-64909-onhost-probe.md\`): the upstream
-> empty-registry bug
+  4. When the worker's completion notification arrives (it lands
+     automatically as a system message), read its result and reply via the
+     channel tool (\`slack.reply\` / \`telegram.reply\` / \`directchat.reply\`)
+     to the same thread / chat / conversation you acknowledged in step 1.
+     **You post the substantive reply \u2014 the worker has no channel tools.**
+  5. If the completion notification reports a failure or an unusable
+     result, tell the user what happened and either re-dispatch with a
+     better prompt or handle it inline \u2014 never go silent.
+
+> **Why background dispatch (and why \`general-purpose\`):** validated
+> 2026-06-10 on Claude Code 2.1.170 (ENG-6274 spike,
+> \`docs/spikes/ENG-6274-run-in-background-dispatch.md\`): background
+> dispatch returns immediately, your turn ends, inbound messages get
+> answered in seconds while the worker runs, and the completion arrives
+> as a notification you handle like any other turn. Use
+> \`subagent_type: general-purpose\` (inherit-all tools) \u2014 NOT
+> \`channel-message-handler\` or \`augmented-worker\` \u2014 until ENG-6273
+> re-verifies on this host that the upstream allowlist bug
 > ([anthropics/claude-code#64909](https://github.com/anthropics/claude-code/issues/64909),
-> 0/6 MCP tools in named sub-agents on 2026-06-03) is **fixed** \u2014 a named
-> sub-agent with an explicit \`tools:\` allowlist binds the full MCP surface
-> again (10/11, zero empty-registry misses). So \`channel-message-handler\`
-> can reach its own channel reply tool: dispatch it in the background and it
-> both does the work AND posts the reply over the audited channel path,
-> while you stay free.
+> empirically 0/6 MCP tools in named sub-agents on 2026-06-03) is fixed
+> at the fleet's pinned Claude Code version. \`general-purpose\` escapes
+> that bug by construction either way.
 
 **Why this triage decision still matters more than any other instruction
 below:** if you skip the acknowledgement and just dive into slow work
@@ -3457,20 +3454,31 @@ consistency.
 
 For background tool work that **isn't** a channel reply \u2014 multi-step data
 pulls, CRM enrichments, research workflows, cross-MCP orchestration \u2014 use
-\`subagent_type: augmented-worker\`. It carries an explicit allowlist of
-every \`mcp__*\` server you have wired \u2014 a tighter, safer tool surface than
-inherit-all \u2014 and binds them reliably now that ENG-6273's on-host probe
-confirmed the upstream allowlist bug (claude-code#64909) is fixed at the
-fleet's pinned Claude Code 2.1.170. For anything expected to take more than
-a minute, add \`run_in_background: true\` so your turn ends and you stay
-responsive; the completion notification brings you the result. Don't
-background-dispatch trivial work \u2014 each dispatch is a fresh context and
-costs real tokens.
+\`subagent_type: general-purpose\` (Anthropic's built-in). It inherits the
+full MCP tool surface from this session and reliably binds every
+\`mcp__*\` server you have available. For anything expected to take more
+than a minute, add \`run_in_background: true\` so your turn ends and you
+stay responsive; the completion notification brings you the result.
+Don't background-dispatch trivial work \u2014 each dispatch is a fresh
+context and costs real tokens.
+
+**Why not \`augmented-worker\` for now:** there is an upstream Claude Code
+bug ([anthropics/claude-code#64909](https://github.com/anthropics/claude-code/issues/64909))
+where sub-agents with an explicit \`tools:\` allowlist get an empty MCP
+tool registry \u2014 every \`mcp__*\` call returns "No such tool available."
+\`general-purpose\` uses \`tools: *\` (inherit-all) and escapes the bug.
+The fix appears to have shipped upstream (verified locally on Claude Code
+2.1.170, 2026-06-10 \u2014 ENG-6269 spike); once ENG-6273 re-verifies it on
+this host's pinned version, \`augmented-worker\` becomes preferred again
+(restricted tool surface for safety + working MCP binding) and
+\`channel-message-handler\` returns as a dispatch target. Until then,
+\`general-purpose\` only.
 
 For slow **channel** replies, see \xA7 FIRST ACTION above \u2014 those are
-dispatched as background \`channel-message-handler\` workers, the channel-aware
-sibling of \`augmented-worker\`, which post the reply themselves over the
-audited channel path.
+dispatched as background \`general-purpose\` workers and **you** post the
+result back to the channel when the completion notification arrives
+(\`channel-message-handler\` is not yet the dispatch target for the same
+ENG-6273-pending reason).
 
 ${activeTasksSection}${personalitySection}## Identity
 
@@ -3500,10 +3508,10 @@ ${resolvedChannels?.includes("slack") ? `
 
 You have a Slack MCP server connected. **First, see \xA7 FIRST ACTION on
 every channel message: triage** at the top of this document \u2014 decide
-fast vs slow before anything else. Handle fast requests inline;
-acknowledge slow ones, then dispatch them to a background
-\`channel-message-handler\` worker (which posts the reply itself) and stay
-responsive \u2014 see the FIRST ACTION section for the full rationale.
+fast vs slow before anything else, then acknowledge inline before
+diving into slow work (sub-agent dispatch for channel replies is
+currently disabled due to an upstream Claude Code bug; see the FIRST
+ACTION section for the full rationale).
 
 For fast requests, respond directly in the conversation. You can also
 proactively use:
@@ -5330,7 +5338,7 @@ If a capability seems missing, **check first** \u2014 run the CLI, list tools (\
 `;
   return `---
 name: augmented-worker
-description: General-purpose background worker for multi-step tool tasks the parent doesn't want to inline (data pulls, multi-API workflows, CRM enrichments, research that needs MCP tools). Has explicit access to every \`mcp__*\` server the parent has wired. Use this \u2014 not \`general-purpose\` and not the read-only researcher/reviewer subagents from other plugins \u2014 whenever the work requires calling MCP tools (e.g. \`mcp__granola__*\`, \`mcp__composio_attio__*\`, \`mcp__slack__*\`, \`mcp__augmented__*\`). Many community subagents declare restrictive \`tools:\` allowlists that exclude MCP tools, so dispatching to them will silently produce "No such tool available." failures and force unsafe fallback paths (reading raw secrets from \`.mcp.json\`, bypassing the Credential Access Control guardrail).
+description: Background worker for multi-step tool tasks the parent doesn't want to inline (data pulls, multi-API workflows, CRM enrichments, research that needs MCP tools). Carries an explicit \`mcp__*\` wildcard allowlist for every server the parent has wired. **Until [anthropics/claude-code#64909](https://github.com/anthropics/claude-code/issues/64909) ships an upstream fix, prefer \`subagent_type: general-purpose\` for MCP-tool dispatch** \u2014 the bug is in Claude Code's sub-agent dispatch path: sub-agents with an explicit \`tools:\` allowlist get an empty MCP tool registry (every \`mcp__*\` call returns "No such tool available."), while \`general-purpose\` (\`tools: *\` inherit-all) correctly binds the full MCP surface. This subagent's allowlist is correct and will work the moment Anthropic lands the fix; until then it is retained for the eventual structural fix and the rare case where you specifically need a restricted tool surface AND can accept the MCP gap. See [[ENG-5938]] for the workaround tracker.
 background: true
 tools: ${tools}
 ---
@@ -5344,7 +5352,7 @@ Your \`tools:\` allowlist (above) names every MCP server the parent has connecte
 ## Hard rules \u2014 Credential Access Control
 
 1. **Never** read raw secrets out of \`.mcp.json\`, \`~/.augmented/*/provision/.mcp.json\`, \`.env.integrations\`, or any agent config file. Those files contain bot tokens, API keys, and OAuth credentials. The Credential Access Control guardrail (\`block_read: true\` on secrets) treats reads of those values as a violation regardless of intent. As **defence-in-depth (not structural enforcement)**, the plugin's \`settings.json\` also denies \`Bash(cat:*/.mcp.json)\`, \`Bash(cat:*/.env.integrations)\`, and \`Bash(jq:*/.mcp.json)\` (ENG-5901 / ADR-0018) \u2014 these block the obvious copy-paste paths but a determined in-process reader can still reach the values; the durable fix is Phase 2/3 of ADR-0018.
-2. **Never** post Slack messages via raw \`chat.postMessage\` + a bot token lifted from config. Use the channel MCP's reply tool (\`mcp__slack__slack_reply\`, \`mcp__telegram__telegram_reply\`, \`mcp__direct-chat__direct_chat_reply\`, etc.) so the call goes through the audited path.
+2. **Never** post channel messages via raw API calls + bot tokens lifted from config. Use the channel MCP reply tools (\`mcp__slack__slack_reply\`, \`mcp__telegram__telegram_reply\`, \`mcp__direct_chat__direct_chat_reply\`, etc.) so calls go through the audited path.
 3. If an \`mcp__*\` tool you expect to be available returns "No such tool available.", **stop and surface the gap to the parent** in your summary rather than working around it. A missing MCP binding is a platform bug worth fixing \u2014 it's the exact failure shape this sub-agent was added to prevent (see ENG-5897 / ENG-5905).
 4. When verifying a capability is wired, confirm the relevant env var exists **without printing its value** \u2014 use \`[ -n "$POSTIZ_API_KEY" ] && echo present || echo absent\`, never \`echo $POSTIZ_API_KEY\`. The Credential Access Control guardrail covers tool-call output as well as file reads.
 
@@ -5816,9 +5824,9 @@ ${sections}`
   // so ensureGatewayRunning() returns early with running=false
   async getVersion() {
     try {
-      const { execFile: execFile4 } = await import("child_process");
+      const { execFile: execFile5 } = await import("child_process");
       return new Promise((resolve3) => {
-        execFile4("claude", ["--version"], { timeout: 5e3 }, (err, stdout) => {
+        execFile5("claude", ["--version"], { timeout: 5e3 }, (err, stdout) => {
           if (err) {
             resolve3(null);
             return;
@@ -7266,7 +7274,7 @@ function requireHost() {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.39" : "dev";
+var agtCliVersion = true ? "0.28.41" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -7662,27 +7670,177 @@ function provision(input, frameworkId = "openclaw") {
   };
 }
 
+// src/lib/connectivity-probe-context.ts
+import { join as join8 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+
+// src/lib/cli-probe.ts
+import { execFile as execFile4 } from "child_process";
+var DEFAULT_TIMEOUT_MS = 8e3;
+function runCliProbe(binary, args, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve3) => {
+    execFile4(
+      binary,
+      args,
+      { timeout: timeoutMs, env: opts.env ?? process.env, windowsHide: true },
+      (err, stdout) => {
+        if (!err) {
+          const firstLine = String(stdout).split(/\r?\n/, 1)[0]?.trim();
+          resolve3({ status: "ok", message: firstLine ? `${binary}: ${firstLine}` : `${binary}: ok` });
+          return;
+        }
+        const e = err;
+        if (e.code === "ENOENT") {
+          resolve3({ status: "down", message: `${binary} not found on PATH (not installed)` });
+          return;
+        }
+        if (e.killed || e.signal === "SIGTERM") {
+          resolve3({ status: "transient_error", message: `${binary} probe timed out after ${timeoutMs / 1e3}s` });
+          return;
+        }
+        resolve3({ status: "down", message: `${binary} exited non-zero: ${e.message}` });
+      }
+    );
+  });
+}
+
+// src/lib/connectivity-probe-context.ts
+function readMcpHttpServerConfig(projectDir, serverKey, env) {
+  try {
+    const raw = readFileSync8(join8(projectDir, ".mcp.json"), "utf-8");
+    const servers = JSON.parse(raw).mcpServers ?? {};
+    const entry = servers[serverKey];
+    if (entry && typeof entry.url === "string" && (entry.type === "http" || entry.type === void 0)) {
+      const unresolved = /* @__PURE__ */ new Set();
+      const sub = (value) => {
+        if (!env) return value;
+        const r = expandTemplateVars(value, env);
+        for (const name of r.unresolved) unresolved.add(name);
+        return r.value;
+      };
+      const url = sub(entry.url);
+      let headers;
+      if (entry.headers) {
+        headers = {};
+        for (const [k, v] of Object.entries(entry.headers)) headers[k] = sub(v);
+      }
+      return { url, ...headers ? { headers } : {}, unresolved: [...unresolved] };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function deriveMcpServerKey(input) {
+  const kind = resolveConnectivityProbe({
+    definitionId: input.definitionId,
+    sourceType: input.sourceType,
+    authType: input.authType,
+    connectivityTest: input.connectivityTest ?? null
+  }).kind;
+  if (kind !== "mcp_tools_list" && kind !== "managed_composite") return void 0;
+  return input.definitionId.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+}
+function buildProbeEnv(projectDir) {
+  const probeEnv = { ...process.env };
+  try {
+    const envIntPath = join8(projectDir, ".env.integrations");
+    if (existsSync8(envIntPath)) {
+      Object.assign(probeEnv, parseEnvIntegrations(readFileSync8(envIntPath, "utf-8")));
+    }
+  } catch {
+  }
+  return probeEnv;
+}
+function buildConnectivityProbeDeps(projectDir, probeEnv) {
+  return {
+    fetchImpl: fetch,
+    runCli: (binary, args) => runCliProbe(binary, args, { env: probeEnv }),
+    mcpProbe: async (target) => {
+      const cfg = readMcpHttpServerConfig(projectDir, target.serverKey, probeEnv);
+      if (!cfg) {
+        return { status: "transient_error", message: `MCP server '${target.serverKey}' not resolvable from .mcp.json` };
+      }
+      if (cfg.unresolved.length > 0) {
+        return {
+          status: "transient_error",
+          message: `MCP '${target.serverKey}' auth unresolved: ${cfg.unresolved.join(", ")}`
+        };
+      }
+      return probeMcpHttp(cfg);
+    },
+    // ENG-6139: connected-account binding check for managed (Composio) toolkits.
+    // The MCP handshake reads green on a dead/mis-bound account, so the managed
+    // probe also verifies the account is ACTIVE + bound to the entity the agent
+    // queries with. Inputs come from the agent's OWN wired MCP server: the
+    // `x-api-key` header and the `user_id` query param (the agent already
+    // authenticates with these), plus the recorded connected_account_id.
+    composioProbe: async (definitionId, credentials) => {
+      const serverKey = definitionId.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+      const cfg = readMcpHttpServerConfig(projectDir, serverKey, probeEnv);
+      if (!cfg) {
+        return { status: "transient_error", message: `MCP server '${serverKey}' not resolvable from .mcp.json` };
+      }
+      if (cfg.unresolved.length > 0) {
+        return {
+          status: "transient_error",
+          message: `MCP '${serverKey}' auth unresolved: ${cfg.unresolved.join(", ")}`
+        };
+      }
+      const apiKey = Object.entries(cfg.headers ?? {}).find(([k]) => k.toLowerCase() === "x-api-key")?.[1] ?? "";
+      let expectedUserId = "";
+      let serverId;
+      try {
+        const u = new URL(cfg.url);
+        expectedUserId = u.searchParams.get("user_id") ?? "";
+        const m = u.pathname.match(/\/v3\/mcp\/([^/]+)\/mcp/);
+        serverId = m?.[1] ? decodeURIComponent(m[1]) : void 0;
+      } catch {
+        expectedUserId = "";
+      }
+      const connectedAccountId = typeof credentials?.["connected_account_id"] === "string" ? credentials["connected_account_id"] : "";
+      return probeComposioAccount({ connectedAccountId, apiKey, expectedUserId, serverId });
+    },
+    // ENG-6157 (Phase 2): the live tool-call leg. Uses the agent's OWN wired MCP
+    // URL + headers (the exact path tool calls take), so a broken auth_config
+    // linkage surfaces as a real `No connected account found` instead of a
+    // green handshake. Skips (`null`) when no safe read-only tool is callable.
+    composioToolCallProbe: async (target) => {
+      const cfg = readMcpHttpServerConfig(projectDir, target.serverKey, probeEnv);
+      if (!cfg) return null;
+      if (cfg.unresolved.length > 0) return null;
+      return probeComposioMcpToolCall({
+        url: cfg.url,
+        headers: cfg.headers,
+        toolName: target.toolName,
+        toolArgs: target.toolArgs
+      });
+    }
+  };
+}
+
 // src/commands/manager.ts
 import chalk3 from "chalk";
-import { existsSync as existsSync9, realpathSync } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10, realpathSync } from "fs";
+import { join as join10 } from "path";
 import { homedir as homedir6, userInfo } from "os";
 import { spawn as spawn3 } from "child_process";
 
 // src/lib/watchdog.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, unlinkSync as unlinkSync4, existsSync as existsSync8, mkdirSync as mkdirSync7, openSync as openSync2, closeSync as closeSync2, chmodSync as chmodSync6 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, unlinkSync as unlinkSync4, existsSync as existsSync9, mkdirSync as mkdirSync7, openSync as openSync2, closeSync as closeSync2, chmodSync as chmodSync6 } from "fs";
+import { join as join9 } from "path";
 import { spawn as spawn2, execFileSync } from "child_process";
-var DEFAULT_CONFIG_DIR = join8(process.env["HOME"] ?? "/tmp", ".augmented");
+var DEFAULT_CONFIG_DIR = join9(process.env["HOME"] ?? "/tmp", ".augmented");
 function getManagerPaths(configDir) {
   return {
-    pidFile: join8(configDir, "manager.pid"),
-    stateFile: join8(configDir, "manager-state.json"),
-    logFile: join8(configDir, "manager.log")
+    pidFile: join9(configDir, "manager.pid"),
+    stateFile: join9(configDir, "manager-state.json"),
+    logFile: join9(configDir, "manager.log")
   };
 }
 function ensureDir2(configDir) {
-  if (!existsSync8(configDir)) {
+  if (!existsSync9(configDir)) {
     mkdirSync7(configDir, { recursive: true });
   }
 }
@@ -7692,7 +7850,7 @@ function writePidFile(configDir, pid) {
 }
 function readPidFile(configDir) {
   try {
-    const raw = readFileSync8(getManagerPaths(configDir).pidFile, "utf-8").trim();
+    const raw = readFileSync9(getManagerPaths(configDir).pidFile, "utf-8").trim();
     const pid = parseInt(raw, 10);
     return isNaN(pid) ? null : pid;
   } catch {
@@ -7730,7 +7888,7 @@ function defaultPgrep() {
 }
 function readStateFile(configDir) {
   try {
-    const raw = readFileSync8(getManagerPaths(configDir).stateFile, "utf-8");
+    const raw = readFileSync9(getManagerPaths(configDir).stateFile, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -7786,7 +7944,7 @@ function startWatchdog(opts) {
     const deadline = Date.now() + 5e3;
     const sleepBuf = new Int32Array(new SharedArrayBuffer(4));
     while (Date.now() < deadline) {
-      if (existsSync8(pidFile)) {
+      if (existsSync9(pidFile)) {
         return { pid: child.pid };
       }
       if (child.exitCode !== null) {
@@ -7914,7 +8072,7 @@ function managerStartCommand(opts) {
     process.exitCode = 1;
     return;
   }
-  const configDir = opts.configDir ?? join9(homedir6(), ".augmented");
+  const configDir = opts.configDir ?? join10(homedir6(), ".augmented");
   if (opts.supervise) {
     if (json) {
       jsonOutput({ ok: false, error: "--supervise is not supported with --json" });
@@ -8010,7 +8168,7 @@ function runSupervisorLoop(intervalSec, configDir) {
 }
 async function managerStopCommand(opts = {}) {
   const json = isJsonMode();
-  const configDir = opts.configDir ?? join9(homedir6(), ".augmented");
+  const configDir = opts.configDir ?? join10(homedir6(), ".augmented");
   try {
     const result = await stopWatchdog(configDir);
     if (!result.stopped && !result.pid) {
@@ -8038,7 +8196,7 @@ async function managerStopCommand(opts = {}) {
 }
 function managerStatusCommand(opts = {}) {
   const json = isJsonMode();
-  const configDir = opts.configDir ?? join9(homedir6(), ".augmented");
+  const configDir = opts.configDir ?? join10(homedir6(), ".augmented");
   const status = getManagerStatus(configDir);
   if (!status) {
     if (json) {
@@ -8110,7 +8268,7 @@ function resolveStableAgtBin(rawPath) {
   if (!prefix || !formula) return rawPath;
   const candidates = [`${prefix}/bin/${formula}`, `${prefix}/bin/agt`];
   for (const candidate of candidates) {
-    if (!existsSync9(candidate)) continue;
+    if (!existsSync10(candidate)) continue;
     try {
       realpathSync(candidate);
       return candidate;
@@ -8130,7 +8288,7 @@ async function managerInstallCommand(opts = {}) {
     process.exitCode = 1;
     return;
   }
-  const configDir = opts.configDir ?? join9(homedir6(), ".augmented");
+  const configDir = opts.configDir ?? join10(homedir6(), ".augmented");
   const rawAgtBin = process.argv[1];
   if (!rawAgtBin) {
     const msg = "Could not resolve the agt binary path from argv. Re-run via the installed `agt` command.";
@@ -8143,7 +8301,7 @@ async function managerInstallCommand(opts = {}) {
   if (process.platform === "darwin") {
     const home = homedir6();
     const protectedRoots = ["Documents", "Downloads", "Desktop", "Movies", "Music", "Pictures"];
-    const offending = protectedRoots.map((r) => join9(home, r)).find((p) => agtBin === p || agtBin.startsWith(`${p}/`));
+    const offending = protectedRoots.map((r) => join10(home, r)).find((p) => agtBin === p || agtBin.startsWith(`${p}/`));
     if (offending) {
       const msg = `agt binary at ${agtBin} sits inside a macOS TCC-protected folder (${offending}). launchd-spawned processes cannot read files there and the manager would EPERM on startup. Either install agt globally (\`npm install -g @integrity-labs/agt-cli\`) or copy the dist outside protected folders before running this command.`;
       if (json) jsonOutput({ ok: false, error: msg });
@@ -8211,7 +8369,7 @@ async function managerInstallSystemUnitCommand(opts = {}) {
     return;
   }
   const user = opts.user ?? "root";
-  const configDir = opts.configDir ?? (user === "root" ? "/root/.augmented" : join9("/home", user, ".augmented"));
+  const configDir = opts.configDir ?? (user === "root" ? "/root/.augmented" : join10("/home", user, ".augmented"));
   const rawAgtBin = process.argv[1];
   if (!rawAgtBin) {
     const msg = "Could not resolve the agt binary path from argv. Re-run via the installed `agt` command.";
@@ -8274,6 +8432,73 @@ async function managerUninstallSystemUnitCommand() {
   }
 }
 
+// src/lib/connectivity-probe-executor.ts
+async function executeConnectivityProbe(target, deps = {}) {
+  const descriptor = resolveConnectivityProbe({
+    definitionId: target.definitionId,
+    sourceType: target.sourceType,
+    authType: target.authType,
+    // ENG-6242: carry the toolkit's connectivity_test override so a managed
+    // descriptor surfaces `probeTool`/`probeArgs` (the prescribed read-only tool)
+    // — without this the hourly probe auto-picked a different tool than the Test
+    // path, the false-RED that flagged every managed Linear install "unreachable".
+    connectivityTest: target.connectivityTest ?? null
+  });
+  if (!descriptor.readOnly) {
+    throw new Error(`Refusing non-read-only probe for ${target.definitionId}`);
+  }
+  switch (descriptor.kind) {
+    case "http_provider":
+      return probeHttpProvider(target.definitionId, target.credentials, deps.fetchImpl ?? fetch);
+    case "composio_account":
+      if (!deps.composioProbe) return null;
+      return deps.composioProbe(target.definitionId, target.credentials);
+    case "managed_composite": {
+      const outcomes = [];
+      if (deps.mcpProbe) {
+        outcomes.push(
+          await deps.mcpProbe({
+            serverKey: target.mcpServerKey ?? target.definitionId,
+            definitionId: target.definitionId
+          })
+        );
+      }
+      if (deps.composioProbe) {
+        outcomes.push(await deps.composioProbe(target.definitionId, target.credentials));
+      }
+      if (deps.composioToolCallProbe) {
+        const toolCall = await deps.composioToolCallProbe({
+          serverKey: target.mcpServerKey ?? target.definitionId,
+          definitionId: target.definitionId,
+          // ENG-6242: thread the prescribed tool through to the live tool-call
+          // leg. resolveConnectivityProbe only sets these for managed toolkits
+          // with a stored override; the probe re-validates read-only and falls
+          // back to auto-pick on drift, so a missing/invalid override is safe.
+          toolName: descriptor.probeTool ?? null,
+          toolArgs: descriptor.probeArgs ?? null
+        });
+        if (toolCall) outcomes.push(toolCall);
+      }
+      if (outcomes.length === 0) return null;
+      return outcomes.reduce((acc, o) => worseConnectivityOutcome(acc, o));
+    }
+    case "mcp_tools_list":
+      if (!deps.mcpProbe) return null;
+      return deps.mcpProbe({
+        serverKey: target.mcpServerKey ?? target.definitionId,
+        definitionId: target.definitionId
+      });
+    case "cli_command":
+      if (!deps.runCli) return null;
+      return deps.runCli(target.cliBinary ?? target.definitionId, descriptor.cliArgs ?? ["--version"]);
+    case "builtin":
+      return { status: "ok", message: `${target.definitionId}: built-in` };
+    case "unsupported":
+    default:
+      return null;
+  }
+}
+
 export {
   getIntegration,
   extractCommandNotFound,
@@ -8315,6 +8540,10 @@ export {
   resolveAllFlags,
   HostFlagStore,
   provision,
+  executeConnectivityProbe,
+  deriveMcpServerKey,
+  buildProbeEnv,
+  buildConnectivityProbeDeps,
   getManagerPaths,
   startWatchdog,
   managerStartCommand,
@@ -8326,4 +8555,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-AL7UJNNI.js.map
+//# sourceMappingURL=chunk-GBST6UWT.js.map