juno-code 1.0.51 → 1.0.53

package/dist/templates/scripts/parallel_runner.sh

@@ -13,10 +13,12 @@ Usage:
   ./parallel_runner.sh --kanban TASK1 TASK2 TASK3 --parallel 2
   ./parallel_runner.sh --kanban "TASK1 TASK2 TASK3"
   ./parallel_runner.sh --kanban T1 T2 --prompt-file instructions.md
+  ./parallel_runner.sh --kanban T1 T2 --prompt "Handle ## {{task_id}} with {{item}}"
+  echo "Handle ## {{task_id}}" | ./parallel_runner.sh --kanban T1 --prompt -
 
-  # Generic items mode (any list, requires --prompt-file with {{item}})
+  # Generic items mode (any list, requires --prompt-file/--prompt with {{item}})
   ./parallel_runner.sh --items "url1,url2,url3" --prompt-file crawl.md
-  ./parallel_runner.sh --items shop1 shop2 shop3 --prompt-file analyze.md
+  ./parallel_runner.sh --items shop1 shop2 shop3 --prompt "Analyze {{item}}"
 
   # File mode (structured data)
   ./parallel_runner.sh --items-file data.jsonl --prompt-file analyze.md
@@ -28,6 +30,7 @@ Usage:
   ./parallel_runner.sh --tmux --kanban T1 T2 --name my-batch
   ./parallel_runner.sh -s codex --kanban T1 T2
   ./parallel_runner.sh -s pi -m gpt-5 --kanban T1 T2
+  ./parallel_runner.sh -s pi --subagent-args "--live" --kanban T1 T2
   ./parallel_runner.sh --stop                    # stop only running session
   ./parallel_runner.sh --stop --name my-batch    # stop specific session
   ./parallel_runner.sh --stop-all                # stop all sessions
@@ -58,7 +61,12 @@ Arguments:
   -m, --model    Model override. Env: JUNO_MODEL.
   --env          Environment overrides. KEY=VALUE pairs or path to .env file.
   --prompt-file  Path to a file whose content is appended to the prompt.
-                 Re-read per task. Placeholders: {{task_id}}, {{item}}, {{file_format}}.
+                 Loaded once at startup; per-task prompt files are materialized under logs/tmp.
+                 Placeholders: {{task_id}}, {{item}}, {{file_format}}.
+  --prompt       Inline prompt template content (same placeholders as --prompt-file).
+                 Use --prompt - to read template content from stdin/heredoc.
+  --subagent-args Extra raw args appended to each juno-code invocation.
+                 Example: --subagent-args "--live --thinking high"
   --tmux         Run in tmux mode. 'windows' (default) or 'panes' (side-by-side).
   --name         Session name (default: auto-generated batch-N). Tmux session = pc-{name}.
   --output-dir   Structured output directory. Default: /tmp/juno-code-sessions/{date}/{run_id}.
@@ -102,6 +110,10 @@ COMBINED_LOG = LOG_DIR / "parallel_runner.log"  # overwritten in main()
 # 5-char alphanumeric run ID, generated once at startup in main()
 _run_id = ""
 
+# Temporary runtime artifacts are stored under logs/tmp and purged periodically.
+_TMP_DIR_NAME = "tmp"
+_TMP_STALE_MAX_AGE_SECONDS = 48 * 60 * 60
+
 # Thread-safe lock for writing to the shared combined log
 _log_lock = threading.Lock()
 
@@ -203,16 +215,36 @@ def _session_name_to_tmux(name):
     return f"pc-{name}"
 
 
+def _tmp_root():
+    return _log_base / _TMP_DIR_NAME
+
+
+def _session_state_root():
+    """Shared state/lock files (dashboard, pause, pid) under logs/tmp."""
+    root = _tmp_root() / ".session_state"
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
 def _dashboard_file(name):
-    return _log_base / f".dashboard_{name}"
+    return _session_state_root() / f"dashboard_{name}"
 
 
 def _pause_file(name):
-    return _log_base / f".pause_{name}"
+    return _session_state_root() / f"pause_{name}"
 
 
 def _pid_file(name):
-    return _log_base / f".orchestrator_pid_{name}"
+    return _session_state_root() / f"orchestrator_pid_{name}"
+
+
+def _legacy_session_state_files(name):
+    """Legacy state/lock files under logs/ root from older runner versions."""
+    return [
+        _log_base / f".dashboard_{name}",
+        _log_base / f".pause_{name}",
+        _log_base / f".orchestrator_pid_{name}",
+    ]
 
 
 def _orchestrator_log(name):
@@ -220,11 +252,61 @@ def _orchestrator_log(name):
 
 
 def _tmp_dir(name):
-    return Path(f"/tmp/pc-{name}")
+    # Keep runtime artifacts under logs/tmp so long-running sessions are
+    # resilient to OS cleanup jobs and temp lifecycle is centralized.
+    return _tmp_root() / name
+
+
+def _legacy_tmp_paths():
+    """Legacy temporary paths from older runner versions (.tmp_*)."""
+    return list(_log_base.glob(".tmp_*"))
+
+
+def _cleanup_tmp_path(path):
+    """Remove a tmp file/dir path safely."""
+    try:
+        if path.is_dir():
+            shutil.rmtree(str(path), ignore_errors=True)
+        else:
+            path.unlink(missing_ok=True)
+        return True
+    except OSError:
+        return False
+
+
+def cleanup_stale_tmp_artifacts(max_age_seconds=_TMP_STALE_MAX_AGE_SECONDS):
+    """Remove stale tmp artifacts older than max_age_seconds.
+
+    Returns number of removed paths.
+    """
+    now = time.time()
+    removed = 0
+
+    candidates = []
+    tmp_root = _tmp_root()
+    if tmp_root.exists():
+        for path in tmp_root.iterdir():
+            if path.name.startswith('.'):
+                continue
+            candidates.append(path)
+
+    candidates.extend(_legacy_tmp_paths())
+
+    for path in candidates:
+        try:
+            age = now - path.stat().st_mtime
+        except OSError:
+            continue
+        if age < max_age_seconds:
+            continue
+        if _cleanup_tmp_path(path):
+            removed += 1
+
+    return removed
 
 
 def _write_log_pipe_helper(name):
-    """Write the Python log-pipe helper to /tmp (once per session)."""
+    """Write the Python log-pipe helper under logs/tmp (once per session)."""
     tmp = _tmp_dir(name)
     tmp.mkdir(parents=True, exist_ok=True)
     helper_path = tmp / "log_pipe.py"
@@ -310,6 +392,51 @@ def _generate_env_exports():
     return "\n".join(lines)
 
 
+def _resolve_subagent_args(raw_args):
+    """Resolve repeatable --subagent-args strings into argv tokens."""
+    resolved = []
+    if not raw_args:
+        return resolved
+    for raw in raw_args:
+        try:
+            resolved.extend(shlex.split(raw))
+        except ValueError as exc:
+            print(f"ERROR: Invalid --subagent-args value '{raw}': {exc}", file=sys.stderr)
+            sys.exit(2)
+    return resolved
+
+
+def _normalize_subagent_args_argv(argv):
+    """Normalize common `subagent-args` invocation shapes before argparse.
+
+    Supports:
+    - `--subagent-args --live` (dash-prefixed value)
+    - `subagent-args --live` (missing leading `--` typo)
+    """
+    normalized = []
+    i = 0
+    while i < len(argv):
+        token = argv[i]
+        if token == "subagent-args":
+            token = "--subagent-args"
+        if token == "--subagent-args" and i + 1 < len(argv):
+            next_token = argv[i + 1]
+            normalized.append(f"--subagent-args={next_token}")
+            i += 2
+            continue
+        normalized.append(token)
+        i += 1
+    return normalized
+
+
+def _contains_live_subagent_flag(subagent_args):
+    """Detect Pi live-mode flags in resolved --subagent-args tokens."""
+    for token in subagent_args or []:
+        if token == "--live" or token.startswith("--live="):
+            return True
+    return False
+
+
 # ---------------------------------------------------------------------------
 # File parsing — multi-format pipeline
 # ---------------------------------------------------------------------------
@@ -544,17 +671,8 @@ def _task_output_path(output_dir, task_id):
     return output_dir / f"{task_id}.json"
 
 
-def _parse_result_from_log(task_log_path):
-    """Parse the juno-code result event from a task log file.
-
-    juno-code prints a JSON line with {"type":"result",...} to stdout.
-    We walk backwards to find it near the end.
-    """
-    try:
-        lines = Path(task_log_path).read_text(encoding="utf-8").splitlines()
-    except (OSError, UnicodeDecodeError):
-        return None
-
+def _parse_result_from_lines(lines):
+    """Parse the most recent juno-code result event from text lines."""
     for line in reversed(lines):
         idx = line.find('{"type":')
         if idx == -1:
@@ -569,6 +687,147 @@ def _parse_result_from_log(task_log_path):
     return None
 
 
+def _parse_result_from_cli_summary_text(clean_text):
+    """Build a synthetic result payload from juno-code CLI summary text.
+
+    This is a fallback when no structured {"type":"result"} object is present in logs.
+    """
+    if not clean_text:
+        return None
+
+    lines = clean_text.splitlines()
+
+    total_cost_usd = None
+    total_cost_match = re.search(r"Total Cost:\s*\$([0-9]+(?:\.[0-9]+)?)", clean_text)
+    if total_cost_match:
+        total_cost_usd = _to_number(total_cost_match.group(1))
+
+    session_id = None
+    # Handles both:
+    #   "Iteration 1: <session>    cost: $..."
+    #   "<session>    cost: $..."
+    session_cost_patterns = [
+        r"Iteration\s+\d+:\s*([^\s]+)\s+cost:\s*\$([0-9]+(?:\.[0-9]+)?)",
+        r"^\s*([^\s]+)\s+cost:\s*\$([0-9]+(?:\.[0-9]+)?)\s*$",
+    ]
+
+    per_session_cost = None
+    for line in lines:
+        for pattern in session_cost_patterns:
+            m = re.search(pattern, line)
+            if not m:
+                continue
+            session_id = m.group(1).strip()
+            per_session_cost = _to_number(m.group(2))
+
+    # Fallback for "Session ID:" section without inline cost.
+    if not session_id:
+        for idx, line in enumerate(lines):
+            if "Session ID" not in line:
+                continue
+            for nxt in lines[idx + 1: idx + 4]:
+                token = nxt.strip()
+                if not token or token.startswith("🔑") or token.startswith("-"):
+                    continue
+                session_id = token.split()[0]
+                break
+            if session_id:
+                break
+
+    result_text = None
+    for idx, line in enumerate(lines):
+        if "📄 Result:" in line or line.strip() == "Result:":
+            collected = []
+            for nxt in lines[idx + 1:]:
+                if (
+                    "📊 Statistics:" in nxt
+                    or nxt.strip() == "Statistics:"
+                    or "🔑 Session ID" in nxt
+                ):
+                    break
+                if nxt.strip():
+                    collected.append(nxt)
+            if collected:
+                result_text = "\n".join(collected).strip()
+            break
+
+    if total_cost_usd is None and per_session_cost is not None:
+        total_cost_usd = per_session_cost
+
+    if session_id is None and total_cost_usd is None and not result_text:
+        return None
+
+    is_error = ("Execution failed" in clean_text) or ("❌" in clean_text)
+
+    payload = {
+        "type": "result",
+        "subtype": "error" if is_error else "success",
+        "is_error": is_error,
+    }
+    if session_id:
+        payload["session_id"] = session_id
+    if total_cost_usd is not None:
+        payload["total_cost_usd"] = total_cost_usd
+    if result_text:
+        payload["result"] = result_text
+
+    return payload
+
+
+def _parse_result_from_text(text):
+    """Parse latest juno-code result event from text output.
+
+    Supports:
+    - single-line JSON event logs
+    - pretty/multi-line JSON blocks
+    - fallback CLI summary lines (session id / cost / result text)
+    """
+    if not text:
+        return None
+
+    # Fast path for compact line-based JSON logs.
+    parsed = _parse_result_from_lines(text.splitlines())
+    if parsed is not None:
+        return parsed
+
+    ansi_re = re.compile(r'\x1b\[[0-9;]*[a-zA-Z]')
+    clean = ansi_re.sub('', text)
+
+    decoder = json.JSONDecoder()
+    idx = 0
+    best = None
+
+    while True:
+        brace = clean.find('{', idx)
+        if brace == -1:
+            break
+
+        try:
+            obj, end = decoder.raw_decode(clean, brace)
+        except json.JSONDecodeError:
+            idx = brace + 1
+            continue
+
+        if isinstance(obj, dict) and obj.get("type") == "result":
+            best = obj
+        idx = max(end, brace + 1)
+
+    if best is not None:
+        return best
+
+    return _parse_result_from_cli_summary_text(clean)
+
+
+def _parse_result_from_log(task_log_path):
+    """Parse the juno-code result event from a task log file."""
+    try:
+        text = Path(task_log_path).read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return None
+
+    return _parse_result_from_text(text)
+
+
 def _extract_response(backend_result, file_format):
     """Extract the clean response from a backend result.
 
@@ -596,6 +855,65 @@ def _extract_response(backend_result, file_format):
     return raw_result, error_msg
 
 
+def _to_number(value):
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        s = value.strip()
+        if not s:
+            return None
+        try:
+            return float(s)
+        except ValueError:
+            return None
+    return None
+
+
+def _extract_total_cost_usd(payload):
+    """Extract total USD cost from structured backend payload variants."""
+    if not isinstance(payload, dict):
+        return None
+
+    for key in ("total_cost_usd", "totalCostUsd", "totalCostUSD"):
+        direct = _to_number(payload.get(key))
+        if direct is not None:
+            return direct
+
+    usage = payload.get("usage")
+    if isinstance(usage, dict):
+        usage_cost = usage.get("cost")
+        if isinstance(usage_cost, dict):
+            nested = _to_number(usage_cost.get("total"))
+            if nested is not None:
+                return nested
+
+    return None
+
+
+def _extract_session_id(payload):
+    """Extract session id from structured backend payload variants."""
+    if not isinstance(payload, dict):
+        return None
+
+    direct = payload.get("session_id")
+    if isinstance(direct, str) and direct.strip():
+        return direct.strip()
+
+    camel = payload.get("sessionId")
+    if isinstance(camel, str) and camel.strip():
+        return camel.strip()
+
+    nested = payload.get("sub_agent_response")
+    if isinstance(nested, dict):
+        sub_id = nested.get("session_id")
+        if isinstance(sub_id, str) and sub_id.strip():
+            return sub_id.strip()
+
+    return None
+
+
 def _write_task_output(output_dir, task_id, exit_code, wall_time, start_time,
                        end_time, worker_id=-1,
                        extracted_response=None, extraction_error=None,
@@ -608,13 +926,13 @@ def _write_task_output(output_dir, task_id, exit_code, wall_time, start_time,
             backend_result, file_format,
         )
 
-    session_id = None
-    if isinstance(backend_result, dict):
-        session_id = backend_result.get("session_id")
+    session_id = _extract_session_id(backend_result)
+    total_cost_usd = _extract_total_cost_usd(backend_result)
 
     task_output = {
         "task_id": task_id,
         "session_id": session_id,
+        "total_cost_usd": total_cost_usd,
         "exit_code": exit_code,
         "wall_time_seconds": round(wall_time, 2),
         "start_time": start_time,
@@ -695,11 +1013,27 @@ def _write_aggregation(output_dir, task_outputs, wall_time, parallelism,
     merged_parts = []
     failed_ids = []
     failed_sessions = {}
+    session_rows = []
+    total_cost_usd = 0.0
     for tid in sorted(task_outputs.keys()):
         t = task_outputs[tid]
         er = t.get("extracted_response")
         br = t.get("backend_result") or {}
         backend_ok = isinstance(br, dict) and br.get("exit_code", -1) == 0
+        sid = t.get("session_id")
+        task_cost = _to_number(t.get("total_cost_usd"))
+        if task_cost is None:
+            task_cost = _extract_total_cost_usd(br)
+        if task_cost is not None:
+            total_cost_usd += task_cost
+
+        session_rows.append({
+            "task_id": tid,
+            "session_id": sid,
+            "total_cost_usd": task_cost,
+            "exit_code": t.get("exit_code"),
+        })
+
         if er and (t.get("exit_code") == 0 or backend_ok):
             if file_format == "csv" and merged_parts:
                 lines = er.split("\n")
@@ -709,7 +1043,6 @@ def _write_aggregation(output_dir, task_outputs, wall_time, parallelism,
                 merged_parts.append(er)
         else:
             failed_ids.append(tid)
-            sid = t.get("session_id")
             if sid:
                 failed_sessions[tid] = sid
 
@@ -727,6 +1060,11 @@ def _write_aggregation(output_dir, task_outputs, wall_time, parallelism,
             "parallelism": parallelism,
             "mode": mode,
             "session_name": session_name,
+            "total_cost_usd": round(total_cost_usd, 10),
+        },
+        "session_summary": {
+            "total_cost_usd": round(total_cost_usd, 10),
+            "tasks": session_rows,
         },
         "merged_extracted": merged_extracted,
         "tasks": task_outputs,
@@ -750,6 +1088,7 @@ def _write_aggregation(output_dir, task_outputs, wall_time, parallelism,
         "failed_ids": failed_ids,
         "failed_sessions": failed_sessions,
         "error_count": len(failed_ids),
+        "total_cost_usd": round(total_cost_usd, 10),
     }
 
 
@@ -763,6 +1102,9 @@ def _format_output_summary(agg_result):
     lines.append(f"  Aggregation:  {agg_result['agg_path']}")
     if agg_result["merged_path"]:
         lines.append(f"  Merged file:  {agg_result['merged_path']}")
+    total_cost_usd = agg_result.get("total_cost_usd")
+    if total_cost_usd is not None:
+        lines.append(f"  Total cost:   ${total_cost_usd:.6f} USD")
     if agg_result["error_count"] > 0:
         lines.append(f"  Errors:       {agg_result['error_count']} chunks failed extraction")
         lines.append(f"  Failed IDs:   {', '.join(agg_result['failed_ids'])}")
@@ -790,6 +1132,14 @@ def _print_output_summary(agg_result):
 # Auto-naming
 # ---------------------------------------------------------------------------
 
+def _iter_pid_files():
+    """Yield current + legacy PID marker files for running-session discovery."""
+    state_root = _session_state_root()
+    if state_root.exists():
+        yield from state_root.glob("orchestrator_pid_*")
+    yield from _log_base.glob(".orchestrator_pid_*")
+
+
 def _next_batch_name():
     """Find the next available batch-N name."""
     existing = set()
@@ -809,8 +1159,13 @@ def _next_batch_name():
     except Exception:
         pass
     try:
-        for f in _log_base.glob(".orchestrator_pid_batch-*"):
-            suffix = f.name[len(".orchestrator_pid_batch-"):]
+        for f in _iter_pid_files():
+            if f.name.startswith("orchestrator_pid_batch-"):
+                suffix = f.name[len("orchestrator_pid_batch-"):]
+            elif f.name.startswith(".orchestrator_pid_batch-"):
+                suffix = f.name[len(".orchestrator_pid_batch-"):]
+            else:
+                continue
             try:
                 existing.add(int(suffix))
             except ValueError:
@@ -830,13 +1185,22 @@ def _next_batch_name():
 def _list_running_sessions():
     """Return list of (name, pid) tuples for running sessions."""
     sessions = []
+    seen_names = set()
     try:
-        for f in _log_base.glob(".orchestrator_pid_*"):
-            name = f.name[len(".orchestrator_pid_"):]
+        for f in _iter_pid_files():
+            if f.name.startswith("orchestrator_pid_"):
+                name = f.name[len("orchestrator_pid_"):]
+            elif f.name.startswith(".orchestrator_pid_"):
+                name = f.name[len(".orchestrator_pid_"):]
+            else:
+                continue
+            if name in seen_names:
+                continue
             try:
                 pid = int(f.read_text().strip())
                 os.kill(pid, 0)
                 sessions.append((name, pid))
+                seen_names.add(name)
             except (ValueError, ProcessLookupError, PermissionError):
                 pass
     except Exception:
@@ -867,7 +1231,7 @@ def _stop_session(name):
         print(f"  Killed tmux session '{tmux_session}'")
         stopped = True
 
-    for f in [pid_path, _dashboard_file(name), _pause_file(name)]:
+    for f in [pid_path, _dashboard_file(name), _pause_file(name), *_legacy_session_state_files(name)]:
         try:
             f.unlink(missing_ok=True)
         except OSError:
@@ -877,6 +1241,11 @@ def _stop_session(name):
     if tmp.exists():
         shutil.rmtree(str(tmp), ignore_errors=True)
 
+    # Backward-compat cleanup for legacy path style.
+    legacy_tmp = _log_base / f".tmp_{name}"
+    if legacy_tmp.exists():
+        shutil.rmtree(str(legacy_tmp), ignore_errors=True)
+
     return stopped
 
 
@@ -1017,7 +1386,15 @@ def parse_args():
     )
     parser.add_argument(
         "--prompt-file", type=str, default=None,
-        help="Prompt template file. Re-read per task. Placeholders: {{task_id}}, {{item}}, {{file_format}}.",
+        help="Prompt template file. Loaded once at startup. Placeholders: {{task_id}}, {{item}}, {{file_format}}.",
+    )
+    parser.add_argument(
+        "--prompt", type=str, default=None,
+        help="Inline prompt template content. Use '-' to read from stdin. Placeholders: {{task_id}}, {{item}}, {{file_format}}.",
+    )
+    parser.add_argument(
+        "--subagent-args", action="append", default=None,
+        help="Extra raw args appended to each juno-code invocation. Repeatable; values are shell-split.",
     )
     parser.add_argument(
         "--tmux", nargs="?", const="windows", default=None, choices=["windows", "panes"],
@@ -1039,7 +1416,8 @@ def parse_args():
         "--stop-all", action="store_true", default=False,
         help="Stop ALL running sessions.",
     )
-    args = parser.parse_args()
+    normalized_argv = _normalize_subagent_args_argv(sys.argv[1:])
+    args = parser.parse_args(normalized_argv)
 
     # Handle stop commands first
     if args.stop_all:
@@ -1047,6 +1425,9 @@ def parse_args():
     if args.stop:
         return args
 
+    if args.prompt_file and args.prompt:
+        parser.error("Use either --prompt-file or --prompt, not both")
+
     # Resolve --kanban-filter -> --kanban
     if args.kanban_filter:
         if args.kanban:
@@ -1089,6 +1470,21 @@ def parse_args():
     global _env_overrides
     _env_overrides = _resolve_env_overrides(args.env)
 
+    args.subagent_args_list = _resolve_subagent_args(args.subagent_args)
+
+    live_in_tmux = args.tmux and _contains_live_subagent_flag(args.subagent_args_list)
+    if live_in_tmux and args.parallel > 1:
+        parser.error(
+            "--tmux with --subagent-args '--live' is interactive and only supports --parallel 1. "
+            "Set --parallel 1, remove --live, or run headless mode."
+        )
+    if live_in_tmux:
+        print(
+            "WARNING: --tmux with --subagent-args '--live' enables interactive Pi TUI in the worker pane; "
+            "batch progress resumes after you exit that live session.",
+            file=sys.stderr,
+        )
+
     # Flatten --kanban
     if args.kanban:
         flat = []
@@ -1153,17 +1549,56 @@ def format_duration(seconds):
     return f"{hours}h {mins}m {secs:.0f}s"
 
 
-def resolve_prompt_file(args, pwd):
-    """Resolve the prompt file path, exit if not found."""
-    if not args.prompt_file:
-        return None
-    prompt_path = Path(args.prompt_file)
-    if not prompt_path.is_absolute():
-        prompt_path = Path(pwd) / prompt_path
-    if not prompt_path.exists():
-        print(f"ERROR: Prompt file not found: {prompt_path}", file=sys.stderr)
-        sys.exit(2)
-    return str(prompt_path)
+def resolve_prompt_source(args, pwd):
+    """Resolve prompt source metadata and return (source_label, template_text)."""
+    if args.prompt_file:
+        prompt_path = Path(args.prompt_file)
+        if not prompt_path.is_absolute():
+            prompt_path = Path(pwd) / prompt_path
+        if not prompt_path.exists():
+            print(f"ERROR: Prompt file not found: {prompt_path}", file=sys.stderr)
+            sys.exit(2)
+        try:
+            template = prompt_path.read_text(encoding="utf-8")
+        except Exception as exc:
+            print(f"ERROR: Could not read prompt file at startup: {exc}", file=sys.stderr)
+            sys.exit(2)
+        return str(prompt_path), template
+
+    if args.prompt is not None:
+        if args.prompt == "-":
+            if sys.stdin.isatty():
+                print("ERROR: --prompt - requires redirected stdin (pipe/heredoc)", file=sys.stderr)
+                sys.exit(2)
+            template = sys.stdin.read()
+            if not template.strip():
+                print("ERROR: --prompt - received empty stdin content", file=sys.stderr)
+                sys.exit(2)
+            return "stdin", template
+        return "inline", args.prompt
+
+    return None, None
+
+
+def render_prompt(task_id, prompt_template, file_format=""):
+    """Render prompt template placeholders for a task."""
+    if not prompt_template:
+        return ""
+    rendered = prompt_template.replace("{{task_id}}", task_id)
+    rendered = rendered.replace("{{item}}", _item_map.get(task_id, task_id))
+    rendered = rendered.replace("{{file_format}}", file_format)
+    return "\n\n---\n\n" + rendered
+
+
+def prepare_prompt_files(task_ids, prompt_template, prompt_dir, file_format=""):
+    """Materialize all per-task prompt files at startup for long-running resilience."""
+    prompt_paths = {}
+    prompt_dir.mkdir(parents=True, exist_ok=True)
+    for task_id in task_ids:
+        prompt_path = prompt_dir / f"prompt_{task_id}.txt"
+        prompt_path.write_text(render_prompt(task_id, prompt_template, file_format), encoding="utf-8")
+        prompt_paths[task_id] = str(prompt_path)
+    return prompt_paths
 
 
 def print_summary(task_ids, results, task_times, wall_elapsed, total_tasks):
@@ -1209,8 +1644,9 @@ def print_summary(task_ids, results, task_times, wall_elapsed, total_tasks):
 # Headless mode
 # ---------------------------------------------------------------------------
 
-def run_task(task_id, semaphore, pwd, prompt_file_path=None, output_dir=None,
-             service="claude", model=":sonnet", file_format="", strict=False):
+def run_task(task_id, semaphore, pwd, prompt_path=None, output_dir=None,
+             service="claude", model=":sonnet", file_format="", strict=False,
+             subagent_args=None):
     """Run a single juno-code subprocess (called from its own thread)."""
     global _completed_count
 
@@ -1222,37 +1658,28 @@ def run_task(task_id, semaphore, pwd, prompt_file_path=None, output_dir=None,
 
         task_log_path = LOG_DIR / f"task_{task_id}.log"
 
-        prompt = ""
-
-        if prompt_file_path:
-            try:
-                extra = Path(prompt_file_path).read_text(encoding="utf-8")
-                extra = extra.replace("{{task_id}}", task_id)
-                extra = extra.replace("{{item}}", _item_map.get(task_id, task_id))
-                extra = extra.replace("{{file_format}}", file_format)
-                prompt += "\n\n---\n\n" + extra
-                log_combined(f"Loaded prompt file ({len(extra)} chars)", task_id)
-            except Exception as e:
-                log_combined(f"WARNING: Could not read prompt file: {e}", task_id)
-
-        tmp_prompt_dir = Path("/tmp/pc-headless")
-        tmp_prompt_dir.mkdir(parents=True, exist_ok=True)
-        tmp_prompt_path = tmp_prompt_dir / f"prompt_{task_id}.txt"
-        tmp_prompt_path.write_text(prompt, encoding="utf-8")
+        if prompt_path and not Path(prompt_path).exists():
+            log_combined("Prompt file missing at runtime; task cannot start", task_id)
+            return task_id, 1
 
         env = _build_process_env()
 
+        cmd = [
+            "juno-code",
+            "-b", "shell",
+            "-s", service,
+            "-m", model,
+            "-i", "1",
+            "-v",
+            "--no-hooks",
+        ]
+        if subagent_args:
+            cmd.extend(subagent_args)
+        if prompt_path:
+            cmd.extend(["-f", str(prompt_path)])
+
         proc = subprocess.Popen(
-            [
-                "juno-code",
-                "-b", "shell",
-                "-s", service,
-                "-m", model,
-                "-i", "1",
-                "-v",
-                "--no-hooks",
-                "-f", str(tmp_prompt_path),
-            ],
+            cmd,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             cwd=pwd,
@@ -1270,11 +1697,6 @@ def run_task(task_id, semaphore, pwd, prompt_file_path=None, output_dir=None,
         proc.wait()
         reader.join()
 
-        try:
-            tmp_prompt_path.unlink(missing_ok=True)
-        except OSError:
-            pass
-
         elapsed = time.monotonic() - start
 
         with _completed_lock:
@@ -1312,7 +1734,8 @@ def run_task(task_id, semaphore, pwd, prompt_file_path=None, output_dir=None,
         semaphore.release()
 
 
-def run_headless_mode(args, pwd, prompt_file_path, output_dir, service, model):
+def run_headless_mode(args, pwd, prompt_source_label, prompt_template,
+                      output_dir, service, model, subagent_args=None):
     """Run tasks in headless mode using ThreadPoolExecutor."""
     global _total_tasks
     _total_tasks = len(args.kanban)
@@ -1329,8 +1752,11 @@ def run_headless_mode(args, pwd, prompt_file_path, output_dir, service, model):
                      + (f"\n  ... and {len(args.kanban) - 3} more" if len(args.kanban) > 3 else ""))
     log_combined(f"Parallelism: {args.parallel}")
     log_combined(f"Service: {service} | Model: {model}")
-    if prompt_file_path:
-        log_combined(f"Prompt file: {prompt_file_path} (re-read per task)")
+    if subagent_args:
+        log_combined(f"Subagent args: {' '.join(subagent_args)}")
+    if prompt_source_label:
+        source_type = "Prompt file" if prompt_source_label not in ("inline", "stdin") else "Prompt source"
+        log_combined(f"{source_type}: {prompt_source_label} (materialized at startup)")
     if output_dir:
         log_combined(f"Output dir: {output_dir}")
     legend = "  ".join(f"{_color_for(tid)} {tid}" for tid in args.kanban)
@@ -1345,10 +1771,16 @@ def run_headless_mode(args, pwd, prompt_file_path, output_dir, service, model):
     file_format = getattr(args, "file_format", "") or ""
     strict = getattr(args, "strict", False)
 
+    prompt_paths = {}
+    if prompt_template is not None:
+        prompt_dir = _tmp_dir(_run_id) / "prompts"
+        prompt_paths = prepare_prompt_files(args.kanban, prompt_template, prompt_dir, file_format)
+        log_combined(f"Prebuilt {len(prompt_paths)} prompt files in {prompt_dir}")
+
     with ThreadPoolExecutor(max_workers=len(args.kanban)) as pool:
         futures = {
-            pool.submit(run_task, task_id, semaphore, pwd, prompt_file_path, output_dir,
-                        service, model, file_format, strict): task_id
+            pool.submit(run_task, task_id, semaphore, pwd, prompt_paths.get(task_id), output_dir,
+                        service, model, file_format, strict, subagent_args): task_id
             for task_id in args.kanban
         }
 
@@ -1384,6 +1816,7 @@ def run_headless_mode(args, pwd, prompt_file_path, output_dir, service, model):
         )
         _print_output_summary(agg_result)
 
+    shutil.rmtree(str(_tmp_dir(_run_id)), ignore_errors=True)
     sys.exit(1 if failed > 0 else 0)
 
 
@@ -1409,6 +1842,8 @@ class TaskState:
     sentinel_id: str = ""
     start_time_iso: str = ""
     end_time_iso: str = ""
+    session_id: str = ""
+    total_cost_usd: float = 0.0
 
 
 @dataclass
@@ -1525,62 +1960,57 @@ def create_tmux_session(session_name, mode, num_workers, pwd):
 # Tmux mode — command building & dispatch
 # ---------------------------------------------------------------------------
 
-def write_runner_script(task_id, pwd, prompt_file_path, session_name_short,
+def write_runner_script(task_id, pwd, prompt_path, session_name_short,
                         output_dir=None, service="claude", model=":sonnet",
-                        file_format=""):
-    """Write prompt file + bash runner script for a task."""
-    prompt = ""
-
-    if prompt_file_path:
-        try:
-            extra = Path(prompt_file_path).read_text(encoding="utf-8")
-            extra = extra.replace("{{task_id}}", task_id)
-            extra = extra.replace("{{item}}", _item_map.get(task_id, task_id))
-            extra = extra.replace("{{file_format}}", file_format)
-            prompt += "\n\n---\n\n" + extra
-        except Exception:
-            pass
-
+                        file_format="", subagent_args=None):
+    """Write bash runner script for a task."""
     sentinel_id = uuid.uuid4().hex[:12]
 
     tmp = _tmp_dir(session_name_short)
     tmp.mkdir(parents=True, exist_ok=True)
 
-    prompt_path = tmp / f"prompt_{task_id}.txt"
-    prompt_path.write_text(prompt)
-
     env_exports = _generate_env_exports()
 
     env_path = tmp / f"env_{task_id}.sh"
     env_path.write_text(env_exports + "\n")
 
+    subagent_args_shell = " ".join(shlex.quote(arg) for arg in (subagent_args or []))
+    prompt_arg = f" -f {shlex.quote(str(prompt_path))}" if prompt_path else ""
+
     runner_path = tmp / f"run_{task_id}.sh"
     runner_path.write_text(textwrap.dedent("""\
         #!/bin/bash
         source %(env_path)s
         cd %(pwd)s
-        juno-code -b shell -s %(service)s -m %(model)s -i 1 -v --no-hooks \\
-            -f %(prompt_path)s
+        juno-code -b shell -s %(service)s -m %(model)s -i 1 -v --no-hooks%(subagent_args)s%(prompt_arg)s
         echo "___DONE_%(sentinel_id)s_${?}___"
     """) % {
         "env_path": shlex.quote(str(env_path)),
         "pwd": shlex.quote(pwd),
-        "prompt_path": shlex.quote(str(prompt_path)),
+        "prompt_arg": prompt_arg,
         "sentinel_id": sentinel_id,
         "service": shlex.quote(service),
         "model": shlex.quote(model),
+        "subagent_args": f" {subagent_args_shell}" if subagent_args_shell else "",
     })
 
     return str(runner_path), sentinel_id
 
 
-def dispatch_task(worker, task_id, task_state, pwd, prompt_file_path,
+def dispatch_task(worker, task_id, task_state, pwd, prompt_paths,
                   session_name_short, output_dir=None, service="claude",
-                  model=":sonnet", file_format=""):
+                  model=":sonnet", file_format="", subagent_args=None,
+                  prompt_template=None):
     """Send a task command to a worker's tmux pane/window."""
+    prompt_path = prompt_paths.get(task_id)
+    if prompt_path and not Path(prompt_path).exists():
+        prompt_path_obj = Path(prompt_path)
+        prompt_path_obj.parent.mkdir(parents=True, exist_ok=True)
+        prompt_path_obj.write_text(render_prompt(task_id, prompt_template, file_format), encoding="utf-8")
+
     runner_path, sentinel_id = write_runner_script(
-        task_id, pwd, prompt_file_path, session_name_short, output_dir,
-        service, model, file_format)
+        task_id, pwd, prompt_path, session_name_short, output_dir,
+        service, model, file_format, subagent_args)
 
     # FIX-003: Stop old pipe-pane explicitly before starting new one
     tmux_run(["pipe-pane", "-t", worker.tmux_target], check=False)
@@ -1756,7 +2186,9 @@ def update_dashboard_file(task_states, workers, paused, wall_start, session_name
     lines.append("")
     lines.append("-" * 58)
     elapsed = format_duration(now - wall_start)
+    total_cost_usd = sum(t.total_cost_usd for t in task_states.values() if t.total_cost_usd > 0)
     lines.append(f"  Pending: {pending}  |  Running: {running}  |  Done: {done}  |  Failed: {failed}  |  Total: {total}")
+    lines.append(f"  Total Cost (USD): ${total_cost_usd:.6f}")
     if total > 0:
         completed = done + failed
         remaining = pending + running
@@ -1777,7 +2209,11 @@ def update_dashboard_file(task_states, workers, paused, wall_start, session_name
         lines.append(f"  [{bar}] {pct}% ({completed}/{total})  Wall: {elapsed}{eta_str}")
     lines.append("-" * 58)
 
-    dashboard_path.write_text("\n".join(lines) + "\n")
+    # Write atomically so tmux dashboard readers never see a partially-written frame.
+    dashboard_content = "\n".join(lines) + "\n"
+    dashboard_tmp_path = dashboard_path.parent / f"{dashboard_path.name}.tmp"
+    dashboard_tmp_path.write_text(dashboard_content, encoding="utf-8")
+    os.replace(dashboard_tmp_path, dashboard_path)
     update_tmux_status_bar(task_states, paused, wall_start, session_name)
 
 
@@ -1785,10 +2221,10 @@ def update_dashboard_file(task_states, workers, paused, wall_start, session_name
 # Tmux mode — orchestration loop
 # ---------------------------------------------------------------------------
 
-def orchestration_loop(task_states, workers, task_queue, pwd, prompt_file_path,
-                       wall_start, session_name_short, session_name,
+def orchestration_loop(task_states, workers, task_queue, pwd, prompt_paths,
+                       prompt_template, wall_start, session_name_short, session_name,
                        output_dir=None, service="claude", model=":sonnet",
-                       file_format="", strict=False):
+                       file_format="", strict=False, subagent_args=None):
     """Main orchestration loop — polls workers, dispatches tasks, updates dashboard."""
     all_task_ids = list(task_states.keys())
     pause_path = _pause_file(session_name_short)
@@ -1839,9 +2275,9 @@ def orchestration_loop(task_states, workers, task_queue, pwd, prompt_file_path,
 
             # FIX-002: Parse result from log, with capture-pane fallback
             task_log_path = LOG_DIR / f"task_{task_id}.log"
-            backend_result = _parse_result_from_log(task_log_path) if output_dir else None
+            backend_result = _parse_result_from_log(task_log_path)
 
-            if output_dir and backend_result is None:
+            if backend_result is None:
                 try:
                     scrollback = tmux_run([
                         "capture-pane", "-t", worker.tmux_target,
@@ -1850,11 +2286,13 @@ def orchestration_loop(task_states, workers, task_queue, pwd, prompt_file_path,
                     if scrollback:
                         ansi_re = re.compile(r'\x1b\[[0-9;]*[a-zA-Z]')
                         clean = ansi_re.sub('', scrollback)
-                        task_log_path.write_text(clean, encoding="utf-8")
-                        backend_result = _parse_result_from_log(task_log_path)
+                        backend_result = _parse_result_from_text(clean)
                 except Exception:
                     pass
 
+            ts.session_id = _extract_session_id(backend_result) or ""
+            ts.total_cost_usd = _extract_total_cost_usd(backend_result) or 0.0
+
             if strict and file_format and output_dir:
                 exit_code = _extract_strict_output(
                     task_id, task_log_path, output_dir, file_format, exit_code,
@@ -1897,8 +2335,9 @@ def orchestration_loop(task_states, workers, task_queue, pwd, prompt_file_path,
                 next_task_id = task_queue.popleft()
                 dispatch_task(
                     worker, next_task_id, task_states[next_task_id],
-                    pwd, prompt_file_path, session_name_short, output_dir,
-                    service, model, file_format,
+                    pwd, prompt_paths, session_name_short, output_dir,
+                    service, model, file_format, subagent_args,
+                    prompt_template,
                 )
 
         # Update dashboard
@@ -1974,12 +2413,27 @@ def orchestration_loop(task_states, workers, task_queue, pwd, prompt_file_path,
             f"  Fastest task:   {format_duration(fastest)}",
             f"  Slowest task:   {format_duration(slowest)}",
         ])
+    total_cost_usd = sum(ts.total_cost_usd for ts in task_states.values() if ts.total_cost_usd > 0)
     summary_lines.extend([
+        f"  Total cost:     ${total_cost_usd:.6f} USD",
         f"  Run ID:         {_run_id}",
         f"  Per-task logs:  {LOG_DIR}/task_<TASK_ID>.log",
-        "=" * 60,
     ])
 
+    session_rows = []
+    for tid in all_task_ids:
+        ts = task_states[tid]
+        if not ts.session_id and ts.total_cost_usd <= 0:
+            continue
+        session_rows.append((tid, ts.session_id or "-", ts.total_cost_usd))
+
+    if session_rows:
+        summary_lines.append("  Session summary:")
+        for tid, sid, cost in session_rows:
+            summary_lines.append(f"    {tid}: session_id={sid}, cost=${cost:.6f}")
+
+    summary_lines.append("=" * 60)
+
     with open(COMBINED_LOG, "a") as f:
         for line in summary_lines:
             f.write(f"[{timestamp}] {line}\n")
@@ -2031,7 +2485,8 @@ def orchestration_loop(task_states, workers, task_queue, pwd, prompt_file_path,
 # Tmux mode — entry point
 # ---------------------------------------------------------------------------
 
-def run_tmux_mode(args, pwd, prompt_file_path, output_dir, service, model):
+def run_tmux_mode(args, pwd, prompt_source_label, prompt_template, output_dir,
+                  service, model, subagent_args=None):
     """Set up tmux session and run orchestrator."""
     num_workers = args.parallel
     mode = args.tmux
@@ -2060,7 +2515,7 @@ def run_tmux_mode(args, pwd, prompt_file_path, output_dir, service, model):
         except (ValueError, ProcessLookupError, PermissionError):
             pass
 
-    for f in [_dashboard_file(session_name_short), _pause_file(session_name_short), pid_path]:
+    for f in [_dashboard_file(session_name_short), _pause_file(session_name_short), pid_path, *_legacy_session_state_files(session_name_short)]:
         if f.exists():
             f.unlink()
 
@@ -2080,8 +2535,11 @@ def run_tmux_mode(args, pwd, prompt_file_path, output_dir, service, model):
                 f.write(f"[{timestamp}]   ... and {len(args.kanban) - 3} more\n")
         f.write(f"[{timestamp}] Parallelism: {num_workers}\n")
         f.write(f"[{timestamp}] Service: {service} | Model: {model}\n")
-        if prompt_file_path:
-            f.write(f"[{timestamp}] Prompt file: {prompt_file_path} (re-read per task)\n")
+        if subagent_args:
+            f.write(f"[{timestamp}] Subagent args: {' '.join(subagent_args)}\n")
+        if prompt_source_label:
+            source_type = "Prompt file" if prompt_source_label not in ("inline", "stdin") else "Prompt source"
+            f.write(f"[{timestamp}] {source_type}: {prompt_source_label} (materialized at startup)\n")
         if output_dir:
             f.write(f"[{timestamp}] Output dir: {output_dir}\n")
         f.write(f"[{timestamp}] {'=' * 60}\n")
@@ -2097,15 +2555,25 @@ def run_tmux_mode(args, pwd, prompt_file_path, output_dir, service, model):
         task_states[tid] = TaskState(task_id=tid)
     task_queue = deque(args.kanban)
 
+    file_format = getattr(args, "file_format", "") or ""
+    prompt_paths = {}
+    if prompt_template is not None:
+        prompt_dir = _tmp_dir(session_name_short) / "prompts"
+        prompt_paths = prepare_prompt_files(args.kanban, prompt_template, prompt_dir, file_format)
+
     wall_start = time.monotonic()
 
     # Start coordinator dashboard
+    # NOTE (PfU2s8): Clear BEFORE printing each frame.
+    # If clear happens after `cat`, tmux can leave stale prompt/command tails
+    # (e.g. parts of this dashboard_cmd string) stitched into dashboard rows.
+    # Keep: printf '\033[H\033[J'; cat ...
     pid_path_str = shlex.quote(str(pid_path))
     dashboard_file_str = shlex.quote(str(_dashboard_file(session_name_short)))
     dashboard_cmd = (
         f"trap 'kill $(cat {pid_path_str}) 2>/dev/null; exit' INT; "
-        f"while true; do printf '\\033[H'; cat {dashboard_file_str} 2>/dev/null "
-        f"|| echo 'Waiting for dashboard...'; printf '\\033[J'; sleep 2; done"
+        f"while true; do printf '\\033[H\\033[J'; cat {dashboard_file_str} 2>/dev/null "
+        f"|| echo 'Waiting for dashboard...'; sleep 2; done"
     )
     tmux_run(["send-keys", "-t", coordinator_target, dashboard_cmd, "Enter"])
 
@@ -2148,23 +2616,22 @@ def run_tmux_mode(args, pwd, prompt_file_path, output_dir, service, model):
                 if not task_queue:
                     break
                 next_task_id = task_queue.popleft()
-                file_format = getattr(args, "file_format", "") or ""
                 dispatch_task(
                     worker, next_task_id, task_states[next_task_id],
-                    pwd, prompt_file_path, session_name_short, output_dir,
-                    service, model, file_format,
+                    pwd, prompt_paths, session_name_short, output_dir,
+                    service, model, file_format, subagent_args,
+                    prompt_template,
                 )
 
             update_dashboard_file(task_states, workers, False, wall_start,
                                   session_name_short, session_name)
 
-            file_format = getattr(args, "file_format", "") or ""
             strict = getattr(args, "strict", False)
             exit_code = orchestration_loop(
                 task_states, workers, task_queue,
-                pwd, prompt_file_path, wall_start,
+                pwd, prompt_paths, prompt_template, wall_start,
                 session_name_short, session_name, output_dir,
-                service, model, file_format, strict,
+                service, model, file_format, strict, subagent_args,
             )
         except Exception:
             import traceback
@@ -2226,16 +2693,20 @@ def main():
         _task_color_map[tid] = _TASK_COLORS[i % len(_TASK_COLORS)]
 
     service, model = _resolve_service_model(args)
-    prompt_file_path = resolve_prompt_file(args, pwd)
+    prompt_source_label, prompt_template = resolve_prompt_source(args, pwd)
     output_dir = _resolve_output_dir(args)
+    subagent_args = getattr(args, "subagent_args_list", [])
 
     _log_base.mkdir(parents=True, exist_ok=True)
+    removed_tmp = cleanup_stale_tmp_artifacts()
+    if removed_tmp > 0:
+        print(f"[parallel_runner] Removed {removed_tmp} stale tmp artifact(s) older than 48h")
     LOG_DIR.mkdir(parents=True, exist_ok=True)
 
     if args.tmux:
-        run_tmux_mode(args, pwd, prompt_file_path, output_dir, service, model)
+        run_tmux_mode(args, pwd, prompt_source_label, prompt_template, output_dir, service, model, subagent_args)
     else:
-        run_headless_mode(args, pwd, prompt_file_path, output_dir, service, model)
+        run_headless_mode(args, pwd, prompt_source_label, prompt_template, output_dir, service, model, subagent_args)
 
 
 if __name__ == "__main__":