@integrity-labs/agt-cli 0.27.149 → 0.27.150-test.16

package/dist/{chunk-XWZMKHHG.js → chunk-QHEAAPEG.js}

@@ -10,7 +10,7 @@ import {
   registerFramework,
   resolveAvatarEnvUrl,
   wrapScheduledTaskPrompt
-} from "./chunk-A75AOK6E.js";
+} from "./chunk-WOOYOAPG.js";
 
 // ../../packages/core/dist/integrations/registry.js
 var INTEGRATION_REGISTRY = [
@@ -3386,32 +3386,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 first, then handle inline.
+- **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. Do the work yourself in this same session. Use whatever tools you
-     need (MCP, skills, file reads, etc.) \u2014 your parent session has the
-     full MCP surface bound.
-  3. Reply with the result via the channel tool (\`slack.reply\` /
-     \`telegram.reply\` / \`directchat.reply\`), addressing the same thread
-     / chat / conversation you acknowledged in step 1.
-
-> **Why inline and not sub-agent dispatch right now:** there is an
-> upstream Claude Code bug
-> ([anthropics/claude-code#64909](https://github.com/anthropics/claude-code/issues/64909))
-> where sub-agents dispatched via the Task tool with an explicit
-> \`tools:\` allowlist (which is the shape \`channel-message-handler\`
-> uses) get an **empty MCP tool registry** \u2014 every \`mcp__*\` call
-> returns "No such tool available", including the channel reply tools.
-> Dispatching a slow channel reply to \`channel-message-handler\` will
-> therefore silently fail to land: you'd post the one-line ack, the
-> sub-agent would do the analysis fine, but its \`slack.reply\` call
-> would error and the user would never see the substantive reply.
-> Empirically confirmed 2026-06-03 with a 6-tool probe: 0/6 MCP tools
-> bound inside \`channel-message-handler\`. Until Anthropic ships the
-> fix, handling slow channel replies inline is the only working path.
+  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. 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),
+> 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
@@ -3433,25 +3444,29 @@ 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: 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.
+\`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.
-Once Anthropic ships the fix, \`augmented-worker\` becomes preferred again
-(restricted tool surface for safety + working MCP binding); the dispatch
-recommendation here will flip back automatically.
+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
-currently handled inline (not dispatched) because \`channel-message-handler\`
-shares the explicit-allowlist shape and so suffers the same upstream
-bug. Empirically confirmed 2026-06-03 on agt-aws-1 with a 6-tool probe:
-0/6 MCP tools bound inside \`channel-message-handler\` (matching the
-\`augmented-worker\` result). When Anthropic ships the upstream fix, both
-named sub-agents will work again and the FIRST ACTION triage will switch
-back to dispatch.
+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
 
@@ -4463,7 +4478,13 @@ function provisionStopHook(codeName) {
     "# tag (slack-channel.ts:1247 / telegram-channel.ts:776 emit content +",
     "# meta which Claude Code wraps in a <channel ...> preamble). Searching",
     "# the raw text gives us the exact pending conversation key.",
-    `CHANNEL_TAG=$(tail -400 "$TRANSCRIPT_PATH" | jq -r '(.message.content // .content // []) | map(select(.type == "text") | .text) | join(" ")' 2>/dev/null | grep -oE '<channel [^>]+>' | tail -1 || true)`,
+    "# User-event content is frequently a PLAIN STRING (channel notifications",
+    "# land that way), not a content-block array \u2014 map() over a string is a",
+    "# jq error, which the 2>/dev/null swallowed, so the tag came back empty",
+    "# and recovery silently no-oped on every Slack ghost reply (confirmed",
+    "# live on sherlock/agt-aws-1 2026-06-10). Normalize string \u2192 one text",
+    "# block before mapping.",
+    `CHANNEL_TAG=$(tail -400 "$TRANSCRIPT_PATH" | jq -r '(.message.content // .content // []) | if type == "string" then [{type: "text", text: .}] else . end | map(select(.type == "text") | .text) | join(" ")' 2>/dev/null | grep -oE '<channel [^>]+>' | tail -1 || true)`,
     'TAG_SOURCE=""',
     `if [ -n "$CHANNEL_TAG" ]; then TAG_SOURCE=$(echo "$CHANNEL_TAG" | grep -oE 'source="[^"]+"' | head -1 | sed 's/source="\\(.*\\)"/\\1/' || true); fi`,
     'extract_attr() { echo "$1" | grep -oE "$2=\\"[^\\"]+\\"" | head -1 | sed -E "s/$2=\\"(.*)\\"/\\\\1/"; }',
@@ -4881,111 +4902,6 @@ function provisionOrientHook(codeName) {
   settings["hooks"] = hooks;
   writeFileSync5(settingsPath, JSON.stringify(settings, null, 2));
 }
-function provisionSessionStateHook(codeName) {
-  const projectDir = getProjectDir(codeName);
-  const claudeDir = join4(projectDir, ".claude");
-  mkdirSync4(claudeDir, { recursive: true });
-  const homeDir = getHomeDir3();
-  const agentDir = join4(homeDir, ".augmented", codeName);
-  const hookScriptPath = join4(claudeDir, "agt-session-state-hook.sh");
-  const hookScript = `#!/usr/bin/env bash
-# Auto-generated by Augmented (ENG-6233 / ENG-6268) \u2014 SessionStart session-state
-# recorder. Writes the model + session origin (which only the agent's own
-# Claude Code session knows) to session-state.json, which the channel servers
-# read back for the /status command. Best-effort, silent; every path exits 0 so
-# it can NEVER block or fail session start.
-# Canonical source: packages/claudecode-plugin-augmented/hooks/session-state.sh
-
-# Best-effort: any unexpected error just exits clean.
-trap 'exit 0' ERR
-
-# Hook input (stdin canonical; CLAUDE_HOOK_INPUT kept as a fallback).
-INPUT="$(cat 2>/dev/null || true)"
-[ -n "$INPUT" ] || INPUT="\${CLAUDE_HOOK_INPUT:-}"
-[ -n "$INPUT" ] || exit 0
-command -v jq >/dev/null 2>&1 || exit 0
-
-# Identity / state dir are baked at provision time.
-CODE_NAME="${codeName}"
-STATE_DIR="${agentDir}"
-mkdir -p "$STATE_DIR" 2>/dev/null || exit 0
-
-# Pull the fields we surface from the SessionStart payload.
-SESSION_ID="$(printf '%s' "$INPUT" | jq -r '.session_id // empty' 2>/dev/null || true)"
-SOURCE="$(printf '%s' "$INPUT" | jq -r '.source // empty' 2>/dev/null || true)"
-MODEL="$(printf '%s' "$INPUT" | jq -r '.model // empty' 2>/dev/null || true)"
-CWD="$(printf '%s' "$INPUT" | jq -r '.cwd // empty' 2>/dev/null || true)"
-[ -n "$CWD" ] || CWD="\${CLAUDE_PROJECT_DIR:-$PWD}"
-
-# Channels: the channel MCP servers wired in the project .mcp.json. The adapter
-# writes each channel as a bare server id \u2014 slack / telegram / msteams (the
-# DEV_CHANNEL_SERVER_IDS set) plus direct-chat \u2014 NOT a "<name>-channel" key, so
-# match that allowlist and exclude the non-channel servers (augmented,
-# cloud-broker, composio_*). The "-channel" suffix only names the bundled .js
-# asset, never the .mcp.json key (verified against a live host, ENG-6268).
-CHANNELS_JSON='[]'
-if [ -f "$CWD/.mcp.json" ]; then
-  CHANNELS_JSON="$(jq -c '
-    ["slack","telegram","msteams","direct-chat"] as $ch
-    | [ (.mcpServers // {} | keys[]) | select(. as $k | $ch | index($k)) ]
-  ' "$CWD/.mcp.json" 2>/dev/null || echo '[]')"
-  [ -n "$CHANNELS_JSON" ] || CHANNELS_JSON='[]'
-fi
-
-# Environment: best-effort from the agent's CLAUDE.md frontmatter (CHARTER.md
-# maps to CLAUDE.md for the Claude Code adapter; the frontmatter carries
-# environment: dev|stage|prod). Missing / unreadable -> omitted.
-ENVIRONMENT=""
-if [ -f "$CWD/CLAUDE.md" ]; then
-  ENVIRONMENT="$(grep -m1 -E '^environment:[[:space:]]*' "$CWD/CLAUDE.md" 2>/dev/null     | sed -E 's/^environment:[[:space:]]*//; s/[[:space:]]*$//' || true)"
-fi
-
-# Seconds->millis keeps this portable across GNU (Linux hosts) and BSD (macOS
-# dev) date; second granularity is plenty for "started 12m ago".
-RECORDED_AT="$(date +%s)000"
-
-# Write atomically (temp + rename) so a concurrent reader never sees a
-# half-written file.
-OUT="$STATE_DIR/session-state.json"
-TMP="$OUT.$$.tmp"
-if jq -nc     --arg session_id "$SESSION_ID"     --arg source "$SOURCE"     --arg model "$MODEL"     --arg cwd "$CWD"     --arg environment "$ENVIRONMENT"     --argjson channels "$CHANNELS_JSON"     --argjson recorded_at "$RECORDED_AT"     '{
-       session_id: $session_id,
-       source: $source,
-       model: $model,
-       cwd: $cwd,
-       channels: $channels,
-       recorded_at: $recorded_at
-     }
-     | if $environment == "" then . else . + { environment: $environment } end'     > "$TMP" 2>/dev/null; then
-  mv -f "$TMP" "$OUT" 2>/dev/null || rm -f "$TMP" 2>/dev/null || true
-else
-  rm -f "$TMP" 2>/dev/null || true
-fi
-
-exit 0
-`;
-  writeFileSync5(hookScriptPath, hookScript, { mode: 493 });
-  const settingsPath = join4(claudeDir, "settings.local.json");
-  let settings = {};
-  try {
-    settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
-  } catch {
-  }
-  const hooks = settings["hooks"] ?? {};
-  const existingSessionStart = Array.isArray(hooks["SessionStart"]) ? [...hooks["SessionStart"]] : [];
-  const alreadyRegistered = existingSessionStart.some((entry) => {
-    const entryHooks = entry.hooks;
-    return Array.isArray(entryHooks) && entryHooks.some((h) => typeof h === "object" && h !== null && h.type === "command" && h.command === hookScriptPath);
-  });
-  if (!alreadyRegistered) {
-    existingSessionStart.push({
-      hooks: [{ type: "command", command: hookScriptPath }]
-    });
-  }
-  hooks["SessionStart"] = existingSessionStart;
-  settings["hooks"] = hooks;
-  writeFileSync5(settingsPath, JSON.stringify(settings, null, 2));
-}
 function modifyJsonConfig(filePath, fn) {
   let originalContent;
   let config;
@@ -7941,7 +7857,6 @@ export {
   provisionIsolationHook,
   provisionAutoKanbanProgressHook,
   provisionOrientHook,
-  provisionSessionStateHook,
   setJsonMode,
   isJsonMode,
   jsonOutput,
@@ -7972,4 +7887,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-XWZMKHHG.js.map
+//# sourceMappingURL=chunk-QHEAAPEG.js.map