@chorus-aidlc/chorus 0.18.0 → 0.18.1

package/.next/standalone/public/chorus-plugin/bin/on-subagent-stop.sh

@@ -4,6 +4,12 @@
 # Auto-checkout from all checked-in tasks, close the Chorus session,
 # clean up state files, and auto-verify if admin AC all passed.
 #
+# Holder-aware: session names are the repeating agent_type, so parallel same-type
+# sub-agents SHARE one session. Teardown (checkout / close / name-keyed state /
+# sessions file / auto-verify) only happens for the LAST holder of the name — see
+# the holder refcount block below. Non-last stops clean up only their own
+# id-keyed state and leave the session running for their siblings.
+#
 # NOTE: SubagentStop does NOT support additionalContext in Claude Code's
 # hookSpecificOutput schema, and systemMessage only reaches the UI —
 # not the main agent's LLM context. All agent-facing reminders must go
@@ -54,47 +60,104 @@ if [ -z "$SESSION_UUID" ]; then
   exit 0
 fi
 
-# === Auto-checkout from all checked-in tasks ===
+# Sanitized form of the name for on-disk paths (same tr sanitization as
+# on-subagent-start.sh uses for sessions/<name>.json and holders/<name>/) —
+# namespaced types such as chorus:code-reviewer must not put a ":" into a path.
+# The state keys keep the raw name.
+AGENT_NAME_FILE=""
+if [ -n "$AGENT_NAME" ]; then
+  AGENT_NAME_FILE=$(printf '%s' "$AGENT_NAME" | tr -c '[:alnum:]._-' '_')
+fi
+
+# === Holder refcount: is this the LAST agent holding the session name? ===
+# Session names are the repeating agent_type, so two parallel sub-agents of the
+# same type share ONE session (reuse-by-name in on-subagent-start.sh). Remove our
+# OWN holder entry first, then count what remains: only the last holder may close
+# the session, auto-checkout, auto-verify or delete the name-keyed state that
+# siblings (and on-teammate-idle.sh) still read.
+#
+# Races are benign and must stay benign: if a sibling's start has not registered
+# its holder yet we may see 0 holders and close the session; that sibling's start
+# then finds a closed/inactive row and reopens it via the existing reopen path.
+# Deliberately no locking.
+#
+# With no name in state we cannot refcount — fall back to the legacy
+# single-agent behaviour (treat this stop as the last holder).
+HOLDERS_DIR=""
+HOLDERS_REMAINING=0
+if [ -n "$AGENT_NAME_FILE" ]; then
+  HOLDERS_DIR="${CHORUS_STATE_DIR}/holders/${AGENT_NAME_FILE}"
+  rm -f "${HOLDERS_DIR}/${AGENT_ID}" 2>/dev/null || true
+  if [ -d "$HOLDERS_DIR" ]; then
+    HOLDERS_REMAINING=$(ls -1 "$HOLDERS_DIR" 2>/dev/null | grep -c . || true)
+  fi
+fi
+[ -n "$HOLDERS_REMAINING" ] || HOLDERS_REMAINING=0
+
+IS_LAST_HOLDER=true
+if [ "$HOLDERS_REMAINING" -gt 0 ]; then
+  IS_LAST_HOLDER=false
+fi
+
+# === Auto-checkout from all checked-in tasks (last holder only) ===
+# Open checkins on a shared session may belong to a still-running sibling, so a
+# non-last stop must not check them out — each sub-agent checks its own task out
+# per the workflow injected by on-subagent-start.sh.
 CHECKOUT_COUNT=0
-SESSION_DETAIL=$("$API" mcp-tool "chorus_get_session" "$(printf '{"sessionUuid":"%s"}' "$SESSION_UUID")" 2>/dev/null) || true
+SESSION_DETAIL=""
+CLOSE_OK=true
 
-if [ -n "$SESSION_DETAIL" ]; then
-  TASK_UUIDS=$(echo "$SESSION_DETAIL" | jq -r '
-    .checkins[]? | select(.checkoutAt == null) | .taskUuid // empty
-  ' 2>/dev/null) || true
+if [ "$IS_LAST_HOLDER" = true ]; then
+  SESSION_DETAIL=$("$API" mcp-tool "chorus_get_session" "$(printf '{"sessionUuid":"%s"}' "$SESSION_UUID")" 2>/dev/null) || true
 
-  if [ -z "$TASK_UUIDS" ]; then
+  if [ -n "$SESSION_DETAIL" ]; then
     TASK_UUIDS=$(echo "$SESSION_DETAIL" | jq -r '
-      .sessionTaskCheckins[]? | select(.checkoutAt == null) | .taskUuid // empty
+      .checkins[]? | select(.checkoutAt == null) | .taskUuid // empty
     ' 2>/dev/null) || true
-  fi
 
-  for TASK_UUID in $TASK_UUIDS; do
-    if [ -n "$TASK_UUID" ]; then
-      "$API" mcp-tool "chorus_session_checkout_task" \
-        "$(printf '{"sessionUuid":"%s","taskUuid":"%s"}' "$SESSION_UUID" "$TASK_UUID")" \
-        >/dev/null 2>&1 || true
-      CHECKOUT_COUNT=$((CHECKOUT_COUNT + 1))
+    if [ -z "$TASK_UUIDS" ]; then
+      TASK_UUIDS=$(echo "$SESSION_DETAIL" | jq -r '
+        .sessionTaskCheckins[]? | select(.checkoutAt == null) | .taskUuid // empty
+      ' 2>/dev/null) || true
     fi
-  done
-fi
 
-# Close the Chorus session via MCP
-CLOSE_OK=true
-"$API" mcp-tool "chorus_close_session" "$(printf '{"sessionUuid":"%s"}' "$SESSION_UUID")" >/dev/null 2>&1 || CLOSE_OK=false
+    for TASK_UUID in $TASK_UUIDS; do
+      if [ -n "$TASK_UUID" ]; then
+        "$API" mcp-tool "chorus_session_checkout_task" \
+          "$(printf '{"sessionUuid":"%s","taskUuid":"%s"}' "$SESSION_UUID" "$TASK_UUID")" \
+          >/dev/null 2>&1 || true
+        CHECKOUT_COUNT=$((CHECKOUT_COUNT + 1))
+      fi
+    done
+  fi
 
-# Clean up state
+  # Close the Chorus session via MCP
+  "$API" mcp-tool "chorus_close_session" "$(printf '{"sessionUuid":"%s"}' "$SESSION_UUID")" >/dev/null 2>&1 || CLOSE_OK=false
+fi
+
+# Clean up state.
+# The id-keyed keys are this agent's own and always go. The name-keyed mapping and
+# the reverse map agent_for_session_<uuid> (single-valued — siblings overwrite it)
+# are shared, so they only go on the last-holder path.
 "$API" state-delete "session_${AGENT_ID}" 2>/dev/null || true
-"$API" state-delete "agent_for_session_${SESSION_UUID}" 2>/dev/null || true
 "$API" state-delete "name_for_agent_${AGENT_ID}" 2>/dev/null || true
-if [ -n "$AGENT_NAME" ]; then
-  "$API" state-delete "session_${AGENT_NAME}" 2>/dev/null || true
+if [ "$IS_LAST_HOLDER" = true ]; then
+  "$API" state-delete "agent_for_session_${SESSION_UUID}" 2>/dev/null || true
+  if [ -n "$AGENT_NAME" ]; then
+    "$API" state-delete "session_${AGENT_NAME}" 2>/dev/null || true
+  fi
 fi
 
-# Clean up session file
+# Clean up session file + holder dir (last holder only — siblings still read
+# sessions/<name>.json, see on-teammate-idle.sh).
 SESSIONS_DIR="${CHORUS_STATE_DIR}/sessions"
-if [ -n "$AGENT_NAME" ] && [ -f "${SESSIONS_DIR}/${AGENT_NAME}.json" ]; then
-  rm -f "${SESSIONS_DIR}/${AGENT_NAME}.json"
+if [ "$IS_LAST_HOLDER" = true ]; then
+  if [ -n "$AGENT_NAME_FILE" ] && [ -f "${SESSIONS_DIR}/${AGENT_NAME_FILE}.json" ]; then
+    rm -f "${SESSIONS_DIR}/${AGENT_NAME_FILE}.json"
+  fi
+  if [ -n "$HOLDERS_DIR" ] && [ -d "$HOLDERS_DIR" ]; then
+    rmdir "$HOLDERS_DIR" 2>/dev/null || true
+  fi
 fi
 
 # Clean up claimed file (written by SubagentStart)
@@ -104,7 +167,9 @@ if [ -n "$AGENT_ID" ] && [ -f "${CLAIMED_DIR}/${AGENT_ID}" ]; then
 fi
 
 # === Auto-verify: if admin marked all AC, verify the task automatically ===
-if [ "$CLOSE_OK" = true ] && [ -n "$SESSION_DETAIL" ]; then
+# Last holder only: on a shared session the first checkin may belong to a sibling,
+# so a non-last stop must never auto-verify another agent's task.
+if [ "$IS_LAST_HOLDER" = true ] && [ "$CLOSE_OK" = true ] && [ -n "$SESSION_DETAIL" ]; then
   FIRST_TASK_UUID=$(echo "$SESSION_DETAIL" | jq -r '
     (.checkins // .sessionTaskCheckins // [])[] | .taskUuid // empty
   ' 2>/dev/null | head -1) || true
@@ -144,7 +209,13 @@ fi
 
 # === Output (UI-only, not visible to main agent LLM) ===
 DISPLAY_NAME="${AGENT_NAME:-${AGENT_ID:0:8}}"
-if [ "$CLOSE_OK" = true ]; then
+if [ "$IS_LAST_HOLDER" != true ]; then
+  # Shared session still has live holders — do not claim it was closed.
+  "$API" hook-output \
+    "Chorus session '${DISPLAY_NAME}' kept open (${HOLDERS_REMAINING} other agent(s) still using it)" \
+    "" \
+    "SubagentStop"
+elif [ "$CLOSE_OK" = true ]; then
   USER_MSG="Chorus session closed: '${DISPLAY_NAME}'"
   if [ "$CHECKOUT_COUNT" -gt 0 ]; then
     USER_MSG="${USER_MSG} (auto-checkout ${CHECKOUT_COUNT} task(s))"

package/.next/standalone/public/chorus-plugin/bin/test-syntax.sh

@@ -140,8 +140,12 @@ assert_eq "no session id -> <slug>/no-session" \
 #    the global root, and does NOT create a .chorus/ in the project dir.
 printf '%s' '{"session_id":"sess-place","tool_input":{"subagent_type":"general-purpose","name":"placer"}}' \
   | "$BASH" "$DIR/on-pre-spawn-agent.sh" >/dev/null 2>&1 || true
-assert_true "pending file written under global root" \
-  test -f "${CHORUS_PLUGIN_STATE_ROOT}/${EXPECT_SLUG}/sess-place/pending/placer"
+# The pending filename is <sanitized subagent_type>__<epoch>-<pid>, never unknown-*.
+PENDING_PLACED="$( ls "${CHORUS_PLUGIN_STATE_ROOT}/${EXPECT_SLUG}/sess-place/pending" 2>/dev/null | head -1 )"
+case "$PENDING_PLACED" in
+  general-purpose__*) assert_true "pending file written under global root" true ;;
+  *)                  assert_true "pending file written under global root" false ;;
+esac
 assert_true "no .chorus/ created in project dir" \
   test ! -d "${CLAUDE_PROJECT_DIR}/.chorus"