1#!/usr/bin/env bash
2 
3set -euo pipefail
4 
5readonly TAG_ORCHESTRATOR="TA_ORCHESTRATOR"
6readonly TAG_AGENT_TYPE="TA_AGENT_TYPE"
7readonly TAG_SESSION_ID="TA_SESSION_ID"
8readonly TAG_WORKSPACE_DIR="TA_WORKSPACE_DIR"
9readonly TAG_AGENT_CWD="TA_AGENT_CWD"
10readonly TAG_JSONL_PATH="TA_JSONL_PATH"
11readonly TAG_LAUNCH_TS="TA_LAUNCH_TS"
12readonly TAG_LAST_SEND_TS="TA_LAST_SEND_TS"
13readonly TAG_LAST_STATE="TA_LAST_STATE"
14 
15readonly DEFAULT_CLAUDE_CMD='claude --dangerously-skip-permissions'
16readonly DEFAULT_CODEX_CMD='codex --dangerously-bypass-approvals-and-sandbox'
17 
18TA_CLAUDE_CMD="${TA_CLAUDE_CMD:-$DEFAULT_CLAUDE_CMD}"
19TA_CODEX_CMD="${TA_CODEX_CMD:-$DEFAULT_CODEX_CMD}"
20TA_CWD="${TA_CWD:-$PWD}"
21TA_TMUX_WIDTH="${TA_TMUX_WIDTH:-200}"
22TA_TMUX_HEIGHT="${TA_TMUX_HEIGHT:-50}"
23TA_CLAUDE_START_DELAY="${TA_CLAUDE_START_DELAY:-5}"
24TA_PASTE_SETTLE_DELAY="${TA_PASTE_SETTLE_DELAY:-0.15}"
25TA_CODEX_PASTE_SETTLE_DELAY="${TA_CODEX_PASTE_SETTLE_DELAY:-1}"
26TA_CODEX_SUBMIT_DELAY="${TA_CODEX_SUBMIT_DELAY:-0.3}"
27TA_WAIT_INTERVAL="${TA_WAIT_INTERVAL:-5}"
28TA_CAPTURE_LINES="${TA_CAPTURE_LINES:-2000}"
29TA_WORKSPACE_ROOT="${TA_WORKSPACE_ROOT:-.tmux-multi-agent/sessions}"
30TA_STATE_DIRNAME="${TA_STATE_DIRNAME:-ta-state}"
31 
32usage() {
33  cat <<'EOF'
34usage:
35  ta claude [name]
36  ta codex [name]
37  ta send [--file|--text] <session> <file-or-text>
38  ta watch <session> [timeout-seconds]
39  ta read <session> [lines]
40  ta ls
41  ta wait <session> [timeout-seconds]
42  ta attach <session>
43  ta kill <session|all>
44  ta help
45 
46env:
47  TA_SESSION_ID or SESSION_ID   Prefix for tmux session names and kill-all scope
48  TA_CWD                        Working directory for launched workers
49  TA_CLAUDE_CMD                 Default: claude --dangerously-skip-permissions
50  TA_CODEX_CMD                  Default: codex --dangerously-bypass-approvals-and-sandbox
51  TA_PASTE_SETTLE_DELAY         Delay after paste before submit (default: 0.15)
52  TA_CODEX_PASTE_SETTLE_DELAY   Codex delay after paste before submit (default: 1)
53 
54notes:
55  These flags are required for non-interactive orchestration. Override via env vars if your
56  setup uses different approval modes.
57 
58  `ta send` defaults to auto mode: existing path => file contents, otherwise literal text.
59  Use `--file` or `--text` to avoid ambiguity.
60EOF
61}
62 
63short_id() {
64  head -c2 /dev/urandom | xxd -p | tr -d '\n'
65}
66 
67now_ms() {
68  python3 - <<'PY'
69import time
70print(int(time.time() * 1000))
71PY
72}
73 
74current_session_id() {
75  printf '%s' "${TA_SESSION_ID:-${SESSION_ID:-}}"
76}
77 
78session_workspace_dir() {
79  local sid
80  sid="$(current_session_id)"
81  if [[ -n "$sid" ]]; then
82    printf '%s/%s' "$TA_WORKSPACE_ROOT" "$sid"
83  else
84    printf '%s' "$TA_WORKSPACE_ROOT"
85  fi
86}
87 
88ta_state_root_dir() {
89  printf '%s/%s' "$(session_workspace_dir)" "$TA_STATE_DIRNAME"
90}
91 
92session_state_dir_path() {
93  printf '%s/%s' "$(ta_state_root_dir)" "$1"
94}
95 
96session_state_file_path() {
97  printf '%s/session.json' "$(session_state_dir_path "$1")"
98}
99 
100session_events_file_path() {
101  printf '%s/events.ndjson' "$(session_state_dir_path "$1")"
102}
103 
104ensure_session_state_dir() {
105  mkdir -p "$(session_state_dir_path "$1")"
106}
107 
108qualify_session_name() {
109  local name="$1"
110  local sid
111  sid="$(current_session_id)"
112  if [[ -n "$sid" && "$name" != "${sid}-"* ]]; then
113    printf '%s-%s\n' "$sid" "$name"
114  else
115    printf '%s\n' "$name"
116  fi
117}
118 
119resolve_session() {
120  local requested="$1"
121  if tmux has-session -t "$requested" 2>/dev/null; then
122    printf '%s\n' "$requested"
123    return 0
124  fi
125 
126  local qualified
127  qualified="$(qualify_session_name "$requested")"
128  if tmux has-session -t "$qualified" 2>/dev/null; then
129    printf '%s\n' "$qualified"
130    return 0
131  fi
132 
133  echo "session not found: $requested" >&2
134  exit 1
135}
136 
137session_matches_scope() {
138  local session="$1"
139  local sid
140  sid="$(current_session_id)"
141  if [[ -z "$sid" ]]; then
142    return 0
143  fi
144  [[ "$session" == "${sid}-"* ]]
145}
146 
147is_tagged_session() {
148  local session="$1"
149  tmux show-environment -t "$session" "$TAG_ORCHESTRATOR" 2>/dev/null | grep -q '^TA_ORCHESTRATOR=tmux-multi-agent$'
150}
151 
152require_managed_session() {
153  local session="$1"
154  if ! is_tagged_session "$session"; then
155    echo "session is not managed by tmux-multi-agent: $session" >&2
156    exit 1
157  fi
158  if ! session_matches_scope "$session"; then
159    echo "session is outside current TA_SESSION_ID scope: $session" >&2
160    exit 1
161  fi
162}
163 
164resolve_managed_session() {
165  local session
166  session="$(resolve_session "$1")"
167  require_managed_session "$session"
168  printf '%s\n' "$session"
169}
170 
171agent_type_for_session() {
172  local session="$1"
173  tmux show-environment -t "$session" "$TAG_AGENT_TYPE" 2>/dev/null | sed 's/^[^=]*=//'
174}
175 
176launch_cwd_for_session() {
177  local session="$1"
178  local cwd
179  cwd="$(tmux show-environment -t "$session" "$TAG_AGENT_CWD" 2>/dev/null | sed 's/^[^=]*=//' || true)"
180  if [[ -n "$cwd" ]]; then
181    printf '%s\n' "$cwd"
182  else
183    tmux display-message -p -t "$session" '#{pane_current_path}' 2>/dev/null || true
184  fi
185}
186 
187capture_non_empty_tail() {
188  local session="$1"
189  local lines="$2"
190  tmux capture-pane -t "$session" -p -S "-${TA_CAPTURE_LINES}" 2>/dev/null | awk 'NF' | tail -n "$lines"
191}
192 
193session_metadata_update() {
194  local session="$1"
195  shift
196  local path
197  ensure_session_state_dir "$session"
198  path="$(session_state_file_path "$session")"
199  python3 - "$path" "$session" "$@" <<'PY'
200import json
201import os
202import sys
203from tempfile import NamedTemporaryFile
204 
205path = sys.argv[1]
206session = sys.argv[2]
207args = sys.argv[3:]
208 
209data = {}
210if os.path.exists(path):
211    try:
212        with open(path) as fh:
213            loaded = json.load(fh)
214        if isinstance(loaded, dict):
215            data = loaded
216    except Exception:
217        data = {}
218 
219data.setdefault("session", session)
220for i in range(0, len(args), 2):
221    key = args[i]
222    value = args[i + 1]
223    if key.endswith(("_ms", "_epoch")):
224        try:
225            data[key] = int(value)
226            continue
227        except ValueError:
228            pass
229    data[key] = None if value == "__null__" else value
230 
231with NamedTemporaryFile("w", delete=False, dir=os.path.dirname(path)) as tmp:
232    json.dump(data, tmp, indent=2, sort_keys=True)
233    tmp.write("\n")
234os.replace(tmp.name, path)
235PY
236}
237 
238session_event_append() {
239  local session="$1"
240  local event="$2"
241  shift 2
242  local path
243  ensure_session_state_dir "$session"
244  path="$(session_events_file_path "$session")"
245  python3 - "$path" "$session" "$event" "$@" <<'PY'
246import json
247import sys
248import time
249 
250path = sys.argv[1]
251session = sys.argv[2]
252event = sys.argv[3]
253args = sys.argv[4:]
254 
255record = {"ts_ms": int(time.time() * 1000), "session": session, "event": event}
256if args:
257    fields = {}
258    for i in range(0, len(args), 2):
259        key = args[i]
260        value = args[i + 1]
261        if key.endswith(("_ms", "_epoch")):
262            try:
263                fields[key] = int(value)
264                continue
265            except ValueError:
266                pass
267        fields[key] = value
268    record["fields"] = fields
269 
270with open(path, "a") as fh:
271    fh.write(json.dumps(record, ensure_ascii=False) + "\n")
272PY
273}
274 
275record_session_state() {
276  local session="$1"
277  local state="$2"
278  local source="${3:-unknown}"
279  local now
280  now="$(now_ms)"
281  tmux set-environment -t "$session" "$TAG_LAST_STATE" "$state" 2>/dev/null || true
282  session_metadata_update "$session" state "$state" state_source "$source" last_activity_ms "$now"
283  session_event_append "$session" "state" state "$state" source "$source"
284}
285 
286pane_pid_for_session() {
287  tmux display-message -p -t "$1" '#{pane_pid}' 2>/dev/null || true
288}
289 
290list_descendant_pids() {
291  local root="$1"
292  local queue=("$root")
293  local pid child
294 
295  while ((${#queue[@]} > 0)); do
296    pid="${queue[0]}"
297    queue=("${queue[@]:1}")
298    [[ -n "$pid" ]] || continue
299    printf '%s\n' "$pid"
300    while IFS= read -r child; do
301      [[ -n "$child" ]] || continue
302      queue+=("$child")
303    done < <(pgrep -P "$pid" 2>/dev/null || true)
304  done
305}
306 
307jsonl_path_via_process_fds() {
308  local session="$1"
309  local agent_type launch_cwd pane_pid pid fd_path target
310  agent_type="$(agent_type_for_session "$session")"
311  launch_cwd="$(launch_cwd_for_session "$session")"
312  pane_pid="$(pane_pid_for_session "$session")"
313  [[ -n "$agent_type" && -n "$pane_pid" ]] || return 1
314 
315  while IFS= read -r pid; do
316    [[ -d "/proc/$pid/fd" ]] || continue
317    for fd_path in /proc/"$pid"/fd/*; do
318      [[ -e "$fd_path" ]] || continue
319      target="$(readlink -f "$fd_path" 2>/dev/null || true)"
320      [[ -n "$target" && -f "$target" ]] || continue
321 
322      if [[ "$agent_type" == "codex" && "$target" == "$HOME"/.codex/sessions/*.jsonl ]]; then
323        printf '%s\n' "$target"
324        return 0
325      fi
326      if [[ "$agent_type" == "claude" && "$target" == "$HOME"/.claude/projects/*.jsonl ]]; then
327        printf '%s\n' "$target"
328        return 0
329      fi
330    done
331  done < <(list_descendant_pids "$pane_pid")
332 
333  return 1
334}
335 
336discover_jsonl_path_for_session() {
337  local session="$1"
338  local agent_type launch_epoch
339  agent_type="$(agent_type_for_session "$session")"
340  launch_epoch="$(tmux show-environment -t "$session" "$TAG_LAUNCH_TS" 2>/dev/null | sed 's/^[^=]*=//' || true)"
341  [[ -n "$agent_type" && -n "$launch_epoch" ]] || return 1
342 
343  if [[ "$agent_type" == "codex" ]]; then
344    find "$HOME/.codex/sessions" -name '*.jsonl' -type f -newermt "@$launch_epoch" 2>/dev/null | sort | tail -n 1
345    return 0
346  fi
347  if [[ "$agent_type" == "claude" ]]; then
348    find "$HOME/.claude/projects" -name '*.jsonl' -type f -newermt "@$launch_epoch" 2>/dev/null | sort | tail -n 1
349    return 0
350  fi
351  return 1
352}
353 
354jsonl_path_for_session() {
355  local session="$1"
356  local cached discovered
357  cached="$(tmux show-environment -t "$session" "$TAG_JSONL_PATH" 2>/dev/null | sed 's/^[^=]*=//' || true)"
358  if [[ -n "$cached" && -f "$cached" ]]; then
359    printf '%s\n' "$cached"
360    return 0
361  fi
362 
363  discovered="$(jsonl_path_via_process_fds "$session" || true)"
364  if [[ -z "$discovered" ]]; then
365    discovered="$(discover_jsonl_path_for_session "$session" || true)"
366  fi
367  if [[ -n "$discovered" && -f "$discovered" ]]; then
368    tmux set-environment -t "$session" "$TAG_JSONL_PATH" "$discovered" 2>/dev/null || true
369    session_metadata_update "$session" jsonl_path "$discovered"
370    session_event_append "$session" "jsonl_bound" path "$discovered"
371    printf '%s\n' "$discovered"
372    return 0
373  fi
374 
375  return 1
376}
377 
378jsonl_completion_snapshot() {
379  local jsonl_path="$1"
380  local agent_type="$2"
381  local last_send_ms="${3:-0}"
382 
383  python3 - "$jsonl_path" "$agent_type" "$last_send_ms" <<'PY'
384import base64
385import datetime as dt
386import json
387import sys
388from collections import deque
389 
390path = sys.argv[1]
391agent_type = sys.argv[2]
392last_send_ms = int(sys.argv[3] or "0")
393records = deque(maxlen=400)
394 
395def parse_ms(value):
396    if not value:
397        return 0
398    try:
399        return int(dt.datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp() * 1000)
400    except Exception:
401        return 0
402 
403try:
404    with open(path) as fh:
405        for line in fh:
406            line = line.strip()
407            if not line:
408                continue
409            try:
410                records.append(json.loads(line))
411            except Exception:
412                pass
413except OSError:
414    print("busy\t")
415    sys.exit(0)
416 
417recent = [obj for obj in records if parse_ms(obj.get("timestamp")) >= last_send_ms]
418if not recent:
419    print("busy\t")
420    sys.exit(0)
421 
422def encode(text):
423    return base64.b64encode((text or "").encode("utf-8")).decode("ascii")
424 
425if agent_type == "codex":
426    message = ""
427    for obj in recent:
428        payload = obj.get("payload")
429        if isinstance(payload, dict) and payload.get("phase") == "final_answer":
430            if isinstance(payload.get("message"), str):
431                message = payload.get("message") or ""
432            else:
433                content = payload.get("content")
434                if isinstance(content, list):
435                    parts = []
436                    for item in content:
437                        if isinstance(item, dict) and item.get("type") == "output_text" and isinstance(item.get("text"), str):
438                            parts.append(item["text"])
439                    message = "\n".join(parts)
440    if message:
441        print(f"idle\t{encode(message)}")
442    else:
443        print("busy\t")
444    sys.exit(0)
445 
446if agent_type == "claude":
447    last = None
448    for obj in recent:
449        if obj.get("type") == "assistant":
450            last = obj
451        elif obj.get("type") == "user":
452            last = None
453    if last is None:
454        print("busy\t")
455        sys.exit(0)
456    message = last.get("message")
457    stop_reason = message.get("stop_reason") if isinstance(message, dict) else None
458    if stop_reason != "end_turn":
459        print("busy\t")
460        sys.exit(0)
461    parts = []
462    content = message.get("content") if isinstance(message, dict) else None
463    if isinstance(content, list):
464        for item in content:
465            if isinstance(item, dict) and item.get("type") in {"text", "output_text"} and isinstance(item.get("text"), str):
466                parts.append(item["text"])
467    print(f"idle\t{encode(chr(10).join(parts))}")
468    sys.exit(0)
469 
470print("busy\t")
471PY
472}
473 
474emit_b64_message() {
475  local encoded="${1:-}"
476  [[ -n "$encoded" ]] || return 0
477  python3 - "$encoded" <<'PY'
478import base64
479import sys
480encoded = sys.argv[1]
481if encoded:
482    sys.stdout.write(base64.b64decode(encoded).decode("utf-8", "replace"))
483PY
484}
485 
486session_state_via_pane() {
487  local session="$1"
488  local tail_text
489  tail_text="$(capture_non_empty_tail "$session" 20)"
490  if grep -Eq 'Working \(|Churned|Computing|Flowing|• Ran |• Explored|• Searched|• Called|Esc to interrupt' <<<"$tail_text"; then
491    record_session_state "$session" "busy" "pane"
492    printf 'busy\n'
493  else
494    record_session_state "$session" "idle" "pane"
495    printf 'idle\n'
496  fi
497}
498 
499session_state() {
500  local session="$1"
501  local agent_type jsonl_path last_send_ms snapshot state encoded
502  agent_type="$(agent_type_for_session "$session")"
503  jsonl_path="$(jsonl_path_for_session "$session" || true)"
504  last_send_ms="$(tmux show-environment -t "$session" "$TAG_LAST_SEND_TS" 2>/dev/null | sed 's/^[^=]*=//' || true)"
505  last_send_ms="${last_send_ms:-0}"
506 
507  if [[ -n "$jsonl_path" && -f "$jsonl_path" ]]; then
508    snapshot="$(jsonl_completion_snapshot "$jsonl_path" "$agent_type" "$last_send_ms")"
509    state="${snapshot%%$'\t'*}"
510    if [[ "$state" == "idle" || "$state" == "busy" ]]; then
511      record_session_state "$session" "$state" "jsonl"
512      printf '%s\n' "$state"
513      return 0
514    fi
515  fi
516 
517  session_state_via_pane "$session"
518}
519 
520watch_session_until_idle() {
521  local session="$1"
522  local timeout="${2:-300}"
523  local emit_output="${3:-false}"
524  local resolved_session elapsed=0 state jsonl_path agent_type last_send_ms snapshot encoded
525 
526  resolved_session="$(resolve_managed_session "$session")"
527  while (( elapsed <= timeout )); do
528    state="$(session_state "$resolved_session")"
529    if [[ "$state" == "idle" ]]; then
530      if [[ "$emit_output" == "true" ]]; then
531        agent_type="$(agent_type_for_session "$resolved_session")"
532        jsonl_path="$(jsonl_path_for_session "$resolved_session" || true)"
533        last_send_ms="$(tmux show-environment -t "$resolved_session" "$TAG_LAST_SEND_TS" 2>/dev/null | sed 's/^[^=]*=//' || true)"
534        if [[ -n "$jsonl_path" && -f "$jsonl_path" ]]; then
535          snapshot="$(jsonl_completion_snapshot "$jsonl_path" "$agent_type" "${last_send_ms:-0}")"
536          encoded="${snapshot#*$'\t'}"
537          if [[ -n "$encoded" ]]; then
538            emit_b64_message "$encoded"
539          fi
540        else
541          capture_non_empty_tail "$resolved_session" 50
542        fi
543      fi
544      return 0
545    fi
546    (( elapsed == timeout )) && break
547    sleep "$TA_WAIT_INTERVAL"
548    elapsed=$((elapsed + TA_WAIT_INTERVAL))
549  done
550  return 1
551}
552 
553load_payload_into_buffer() {
554  local mode="$1"
555  local input="$2"
556  local buffer_name="$3"
557  local temp_file_var_name="$4"
558  local temp_file=""
559 
560  if [[ "$mode" == "file" ]]; then
561    [[ -f "$input" ]] || { echo "file not found: $input