agent-control-plane 0.1.8 → 0.1.12

package/tools/bin/agent-project-run-openclaw-session

@@ -18,6 +18,7 @@ Options:
   --openclaw-model <id>               Model id for the isolated OpenClaw agent
   --openclaw-thinking <level>         OpenClaw thinking level
   --openclaw-timeout-seconds <secs>   OpenClaw local-agent timeout
+  --openclaw-stall-seconds <secs>     Fail when the agent produces no output for too long (0 disables)
   --help                              Show this help
 EOF
 }
@@ -34,9 +35,11 @@ env_prefix=""
 sandbox_subdir=".openclaw-artifacts"
 reconcile_command=""
 keep_agent="false"
-openclaw_model="${ACP_OPENCLAW_MODEL:-${F_LOSNING_OPENCLAW_MODEL:-openrouter/stepfun/step-3.5-flash:free}}"
-openclaw_thinking="${ACP_OPENCLAW_THINKING:-${F_LOSNING_OPENCLAW_THINKING:-adaptive}}"
+openclaw_model="${ACP_OPENCLAW_MODEL:-${F_LOSNING_OPENCLAW_MODEL:-openrouter/qwen/qwen3.6-plus-preview:free}}"
+openclaw_thinking="${ACP_OPENCLAW_THINKING:-${F_LOSNING_OPENCLAW_THINKING:-low}}"
 openclaw_timeout_seconds="${ACP_OPENCLAW_TIMEOUT_SECONDS:-${F_LOSNING_OPENCLAW_TIMEOUT_SECONDS:-900}}"
+openclaw_stall_seconds="${ACP_OPENCLAW_STALL_SECONDS:-${F_LOSNING_OPENCLAW_STALL_SECONDS:-180}}"
+openclaw_progress_heartbeat_seconds="${ACP_OPENCLAW_PROGRESS_HEARTBEAT_SECONDS:-${F_LOSNING_OPENCLAW_PROGRESS_HEARTBEAT_SECONDS:-30}}"
 provided_openclaw_agent_id=""
 provided_openclaw_session_id=""
 provided_openclaw_agent_dir=""
@@ -64,6 +67,7 @@ while [[ $# -gt 0 ]]; do
     --openclaw-model) openclaw_model="${2:-}"; shift 2 ;;
     --openclaw-thinking) openclaw_thinking="${2:-}"; shift 2 ;;
     --openclaw-timeout-seconds) openclaw_timeout_seconds="${2:-}"; shift 2 ;;
+    --openclaw-stall-seconds) openclaw_stall_seconds="${2:-}"; shift 2 ;;
     --openclaw-agent-id) provided_openclaw_agent_id="${2:-}"; shift 2 ;;
     --openclaw-session-id) provided_openclaw_session_id="${2:-}"; shift 2 ;;
     --openclaw-agent-dir) provided_openclaw_agent_dir="${2:-}"; shift 2 ;;
@@ -90,6 +94,13 @@ esac
 case "$openclaw_timeout_seconds" in
   ''|*[!0-9]*) echo "--openclaw-timeout-seconds must be numeric" >&2; exit 1 ;;
 esac
+case "$openclaw_stall_seconds" in
+  ''|*[!0-9]*) echo "--openclaw-stall-seconds must be numeric" >&2; exit 1 ;;
+esac
+case "$openclaw_progress_heartbeat_seconds" in
+  ''|*[!0-9]*) echo "OpenClaw progress heartbeat seconds must be numeric" >&2; exit 1 ;;
+  0) echo "OpenClaw progress heartbeat seconds must be greater than zero" >&2; exit 1 ;;
+esac
 
 if ! command -v openclaw >/dev/null 2>&1; then
   echo "unable to resolve a runnable openclaw binary" >&2
@@ -154,6 +165,8 @@ printf -v openclaw_session_id_q '%q' "$openclaw_session_id"
 printf -v openclaw_model_q '%q' "$openclaw_model"
 printf -v openclaw_thinking_q '%q' "$openclaw_thinking"
 printf -v openclaw_timeout_q '%q' "$openclaw_timeout_seconds"
+printf -v openclaw_stall_q '%q' "$openclaw_stall_seconds"
+printf -v openclaw_progress_heartbeat_q '%q' "$openclaw_progress_heartbeat_seconds"
 printf -v keep_agent_q '%q' "$keep_agent"
 
 {
@@ -180,6 +193,8 @@ printf -v keep_agent_q '%q' "$keep_agent"
   printf 'OPENCLAW_MODEL=%s\n' "$openclaw_model_q"
   printf 'OPENCLAW_THINKING=%s\n' "$openclaw_thinking_q"
   printf 'OPENCLAW_TIMEOUT_SECONDS=%s\n' "$openclaw_timeout_q"
+  printf 'OPENCLAW_STALL_SECONDS=%s\n' "$openclaw_stall_q"
+  printf 'OPENCLAW_PROGRESS_HEARTBEAT_SECONDS=%s\n' "$openclaw_progress_heartbeat_q"
   printf 'OPENCLAW_KEEP_AGENT=%s\n' "$keep_agent_q"
 } >"$meta_file"
 
@@ -265,7 +280,7 @@ fi
 
 reconcile_snippet=""
 if [[ -n "$reconcile_command" ]]; then
-  printf -v delayed_reconcile_q '%q' "sleep 2; $reconcile_command"
+  printf -v delayed_reconcile_q '%q' "export ACP_EXPECTED_RUN_STARTED_AT=${started_at_q}; export F_LOSNING_EXPECTED_RUN_STARTED_AT=${started_at_q}; while tmux has-session -t ${session_q} 2>/dev/null; do sleep 1; done; sleep 2; $reconcile_command"
   reconcile_snippet="nohup bash -lc ${delayed_reconcile_q} >> ${output_q} 2>&1 </dev/null &"
 fi
 
@@ -281,6 +296,7 @@ sandbox_artifact_dir=${sandbox_artifact_dir_q}
 sandbox_run_dir=${sandbox_run_dir_q}
 artifact_dir=${artifact_dir_q}
 run_dir=${artifact_dir_q}
+task_kind=${task_kind_q}
 worktree=${worktree_q}
 prompt_file_path=${prompt_q}
 openclaw_state_dir=${openclaw_state_dir_q}
@@ -291,6 +307,8 @@ openclaw_session_id=${openclaw_session_id_q}
 openclaw_model=${openclaw_model_q}
 openclaw_bin=${openclaw_bin_q}
 openclaw_timeout=${openclaw_timeout_q}
+openclaw_stall_seconds=${openclaw_stall_q}
+openclaw_progress_heartbeat_seconds=${openclaw_progress_heartbeat_q}
 openclaw_thinking=${openclaw_thinking_q}
 keep_agent=${keep_agent_q}
 openclaw_add_log="\${sandbox_run_dir}/openclaw-agents-add.log"
@@ -334,6 +352,9 @@ record_final_git_state() {
 
 ensure_openclaw_workspace_excludes() {
   local exclude_file line
+  if ! git -C ${worktree_q} rev-parse --git-dir >/dev/null 2>&1; then
+    return 0
+  fi
   exclude_file="\$(git -C ${worktree_q} config --worktree --get core.excludesFile 2>/dev/null || true)"
   if [[ -z "\${exclude_file}" ]]; then
     exclude_file="\${sandbox_artifact_dir}/git-exclude"
@@ -357,6 +378,7 @@ IDENTITY.md
 USER.md
 HEARTBEAT.md
 BOOTSTRAP.md
+AGENTS.md
 .agent-session.env
 \$ACP_RUN_DIR
 \$AGENT_PROJECT_RUN_DIR
@@ -558,6 +580,14 @@ classify_failure_reason() {
     printf 'context-length-exceeded\n'
     return 0
   fi
+  if grep -Eiq 'stale-run no-agent-output-before-stall-threshold|no-agent-output-before-stall-threshold' "\${output_file}" 2>/dev/null; then
+    printf 'no-agent-output-before-stall-threshold\n'
+    return 0
+  fi
+  if grep -Eiq 'stale-run no-agent-progress-before-stall-threshold|no-agent-progress-before-stall-threshold' "\${output_file}" 2>/dev/null; then
+    printf 'no-agent-progress-before-stall-threshold\n'
+    return 0
+  fi
   if grep -Eiq 'timeout|timed out|ETIMEDOUT|ECONNREFUSED' "\${output_file}" 2>/dev/null; then
     printf 'timeout\n'
     return 0
@@ -570,6 +600,7 @@ infer_result_from_output() {
   local verification_file="\${sandbox_run_dir}/verification.jsonl"
   # Host-side result file (always writable, never inside worktree)
   local host_result_file="\${run_dir}/result.env"
+  local recovered_contract=""
   local write_result=''
 
   write_result() {
@@ -577,6 +608,38 @@ infer_result_from_output() {
     printf '%b' "\$1" > "\${host_result_file}" 2>/dev/null || true
   }
 
+  recover_result_contract_from_output() {
+    python3 - "\${output_file}" <<'PY'
+import re
+import sys
+
+log_path = sys.argv[1]
+try:
+    raw = open(log_path, "r", encoding="utf-8", errors="replace").read()
+except Exception:
+    raise SystemExit(1)
+
+matches = re.findall(r"Result file written:\s*([^\r\n]+)", raw, flags=re.IGNORECASE)
+if not matches:
+    raise SystemExit(1)
+
+line = matches[-1]
+fields = {}
+for key in ("OUTCOME", "ACTION", "DETAIL", "ISSUE_ID"):
+    match = re.search(rf"{key}=([A-Za-z0-9._/-]+)", line)
+    if match:
+        fields[key] = match.group(1).strip()
+
+if "OUTCOME" not in fields or "ACTION" not in fields:
+    raise SystemExit(1)
+
+for key in ("OUTCOME", "ACTION", "DETAIL", "ISSUE_ID"):
+    value = fields.get(key)
+    if value:
+        print(f"{key}={value}")
+PY
+  }
+
   # If sandbox result.env exists with implemented, validate it has verification
   if [[ -f "\${result_file_path}" ]]; then
     if grep -q 'OUTCOME=implemented' "\${result_file_path}" 2>/dev/null; then
@@ -589,6 +652,17 @@ infer_result_from_output() {
     return 0
   fi
 
+  if grep -Fq '[tools] exec failed: Provide a command to start.' "\${output_file}" 2>/dev/null; then
+    write_result 'OUTCOME=blocked\nACTION=host-comment-blocker\nDETAIL=worker-tool-exec-empty-command\n'
+    return 0
+  fi
+
+  recovered_contract="\$(recover_result_contract_from_output 2>/dev/null || true)"
+  if [[ -n "\${recovered_contract}" ]]; then
+    write_result "\${recovered_contract}"$'\n'
+    return 0
+  fi
+
   # Check if there are actual code changes (not just artifact files)
   local has_product_changes="no"
   if git -C ${worktree_q} diff --name-only HEAD 2>/dev/null | grep -qvE '\.openclaw-artifacts/|\.md$' 2>/dev/null; then
@@ -640,6 +714,79 @@ infer_result_from_output() {
   write_result 'OUTCOME=blocked\nACTION=host-comment-blocker\n'
 }
 
+synthesize_comment_artifact_from_output() {
+  local target_file=""
+  local result_file_path="\${sandbox_run_dir}/result.env"
+
+  if [[ ! -f "\${result_file_path}" ]] || ! grep -Eq '^ACTION=host-comment-' "\${result_file_path}" 2>/dev/null; then
+    return 0
+  fi
+
+  case "\${task_kind}" in
+    issue|task)
+      target_file="\${sandbox_run_dir}/issue-comment.md"
+      ;;
+    pr)
+      target_file="\${sandbox_run_dir}/pr-comment.md"
+      ;;
+    *)
+      return 0
+      ;;
+  esac
+
+  [[ -n "\${target_file}" ]] || return 0
+  [[ ! -f "\${target_file}" ]] || return 0
+
+  python3 - "\${output_file}" "\${target_file}" <<'PY2'
+import json
+import os
+import sys
+
+log_path, target_path = sys.argv[1:3]
+
+try:
+    raw = open(log_path, 'r', encoding='utf-8', errors='replace').read()
+except Exception:
+    raise SystemExit(0)
+
+decoder = json.JSONDecoder()
+message = ''
+idx = 0
+while idx < len(raw):
+    start = raw.find('{', idx)
+    if start == -1:
+        break
+    try:
+        payload, end = decoder.raw_decode(raw, start)
+    except Exception:
+        idx = start + 1
+        continue
+    idx = end
+    if not isinstance(payload, dict):
+        continue
+    payloads = payload.get('payloads')
+    if not isinstance(payloads, list):
+        continue
+    parts = []
+    for item in payloads:
+        if not isinstance(item, dict):
+            continue
+        value = item.get('text')
+        if isinstance(value, str) and value.strip():
+            parts.append(value.rstrip())
+    if parts:
+        message = '\n\n'.join(parts).strip()
+
+if not message:
+    raise SystemExit(0)
+
+os.makedirs(os.path.dirname(target_path), exist_ok=True)
+with open(target_path, 'w', encoding='utf-8') as handle:
+    handle.write(message)
+    handle.write('\n')
+PY2
+}
+
 cleanup_agent() {
   # --force required for non-interactive (tmux) sessions, otherwise delete waits for confirmation
   "\${openclaw_bin}" agents delete "\${openclaw_agent_id}" --json --force >/dev/null 2>&1 || true
@@ -734,7 +881,7 @@ PY
 }
 
 run_openclaw_agent_command() {
-  python3 - "\${output_file}" "\${openclaw_timeout}" "\${openclaw_bin}" "\${openclaw_agent_id}" "\${openclaw_session_id}" "\${openclaw_thinking}" "\${prompt_file_path}" <<'PY'
+  python3 - "\${output_file}" "\${runner_state_file}" "\${openclaw_timeout}" "\${openclaw_stall_seconds}" "\${openclaw_progress_heartbeat_seconds}" "\${openclaw_bin}" "\${openclaw_agent_id}" "\${openclaw_session_id}" "\${openclaw_thinking}" "\${prompt_file_path}" <<'PY'
 import os
 import re
 import selectors
@@ -743,7 +890,7 @@ import subprocess
 import sys
 import time
 
-output_path, timeout_seconds_raw, openclaw_bin, agent_id, session_id, thinking, prompt_path = sys.argv[1:8]
+output_path, runner_state_path, timeout_seconds_raw, stall_seconds_raw, heartbeat_seconds_raw, openclaw_bin, agent_id, session_id, thinking, prompt_path = sys.argv[1:11]
 
 with open(prompt_path, "r", encoding="utf-8") as handle:
     prompt = handle.read()
@@ -766,7 +913,14 @@ cmd = [
 ]
 
 timeout_seconds = float(timeout_seconds_raw)
+stall_seconds = float(stall_seconds_raw)
+heartbeat_seconds = max(float(heartbeat_seconds_raw), 1.0)
 hard_deadline = time.monotonic() + timeout_seconds + 15.0
+started_at = time.monotonic()
+next_heartbeat = time.monotonic() + heartbeat_seconds
+seen_agent_progress = False
+last_agent_progress_at = started_at
+last_progress_source = "none"
 terminal_patterns = [
     re.compile(r"Config was last written by a newer OpenClaw", re.I),
     re.compile(r"invalid api key|authentication failed|unauthorized|provider api key|login required|please authenticate|api_key_invalid", re.I),
@@ -779,6 +933,40 @@ proc = None
 sel = selectors.DefaultSelector()
 matched_terminal_error = False
 tail = ""
+openclaw_state_dir = os.environ.get("OPENCLAW_STATE_DIR", "")
+sandbox_run_dir = (
+    os.environ.get("ACP_RUN_DIR")
+    or os.environ.get("AGENT_PROJECT_RUN_DIR")
+    or os.environ.get("F_LOSNING_RUN_DIR")
+    or ""
+)
+host_managed_prefixes = tuple(
+    prefix
+    for prefix in (
+        os.path.realpath(runner_state_path) if runner_state_path else "",
+        os.path.realpath(output_path) if output_path else "",
+    )
+    if prefix
+)
+
+def write_running_heartbeat() -> None:
+    updated_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    tmp_path = f"{runner_state_path}.tmp.{os.getpid()}"
+    with open(tmp_path, "w", encoding="utf-8") as handle:
+        handle.write("RUNNER_STATE=running\n")
+        handle.write(f"THREAD_ID={sh_quote(session_id)}\n")
+        handle.write("ATTEMPT=1\n")
+        handle.write("RESUME_COUNT=0\n")
+        handle.write("LAST_EXIT_CODE=''\n")
+        handle.write("LAST_FAILURE_REASON=''\n")
+        handle.write("LAST_TRIGGER_REASON=''\n")
+        handle.write("AUTH_WAIT_STARTED_AT=''\n")
+        handle.write("LAST_AUTH_FINGERPRINT=''\n")
+        handle.write(f"UPDATED_AT={sh_quote(updated_at)}\n")
+    os.replace(tmp_path, runner_state_path)
+
+def sh_quote(value: str) -> str:
+    return "'" + value.replace("'", "'\"'\"'") + "'"
 
 def terminate_process_group(process: subprocess.Popen) -> None:
     try:
@@ -795,6 +983,47 @@ def terminate_process_group(process: subprocess.Popen) -> None:
     except ProcessLookupError:
         return
 
+def progress_signature() -> tuple[tuple[str, int, int], ...]:
+    entries: list[tuple[str, int, int]] = []
+
+    def add_file(path: str) -> None:
+        real_path = ""
+        if not path:
+            return
+        try:
+            stat_result = os.stat(path)
+        except OSError:
+            return
+        if not os.path.isfile(path):
+            return
+        real_path = os.path.realpath(path)
+        for prefix in host_managed_prefixes:
+            if real_path == prefix or real_path.startswith(f"{prefix}.tmp."):
+                return
+        entries.append((real_path, stat_result.st_mtime_ns, stat_result.st_size))
+
+    if sandbox_run_dir:
+        try:
+            for name in os.listdir(sandbox_run_dir):
+                add_file(os.path.join(sandbox_run_dir, name))
+        except OSError:
+            pass
+
+    if openclaw_state_dir:
+        sessions_dir = os.path.join(openclaw_state_dir, "agents", agent_id, "sessions")
+        add_file(os.path.join(sessions_dir, "sessions.json"))
+        try:
+            for name in os.listdir(sessions_dir):
+                if name.endswith(".jsonl") and not name.endswith(".lock"):
+                    add_file(os.path.join(sessions_dir, name))
+        except OSError:
+            pass
+
+    entries.sort()
+    return tuple(entries)
+
+last_progress_signature = progress_signature()
+
 with open(output_path, "ab", buffering=0) as log_handle:
     proc = subprocess.Popen(
         cmd,
@@ -817,8 +1046,42 @@ with open(output_path, "ab", buffering=0) as log_handle:
           terminate_process_group(proc)
           break
 
+        current_progress_signature = progress_signature()
+        if current_progress_signature != last_progress_signature:
+            last_progress_signature = current_progress_signature
+            seen_agent_progress = True
+            last_agent_progress_at = time.monotonic()
+            last_progress_source = "session-state"
+            next_heartbeat = time.monotonic() + heartbeat_seconds
+
         events = sel.select(timeout=0.2)
         if not events:
+            if proc.poll() is None and not seen_agent_progress and stall_seconds > 0 and (time.monotonic() - started_at) >= stall_seconds:
+                elapsed = int(time.monotonic() - started_at)
+                write_running_heartbeat()
+                log_handle.write(f"[openclaw] stale-run no-agent-output-before-stall-threshold elapsed={elapsed}s\n".encode("utf-8"))
+                terminate_process_group(proc)
+                break
+            if proc.poll() is None and seen_agent_progress and stall_seconds > 0 and (time.monotonic() - last_agent_progress_at) >= stall_seconds:
+                elapsed = int(time.monotonic() - started_at)
+                idle_for = int(time.monotonic() - last_agent_progress_at)
+                write_running_heartbeat()
+                log_handle.write(f"[openclaw] stale-run no-agent-progress-before-stall-threshold elapsed={elapsed}s idle={idle_for}s\n".encode("utf-8"))
+                terminate_process_group(proc)
+                break
+            if proc.poll() is None and not seen_agent_progress and time.monotonic() >= next_heartbeat:
+                elapsed = int(time.monotonic() - started_at)
+                write_running_heartbeat()
+                log_handle.write(f"[openclaw] heartbeat waiting-for-agent-output elapsed={elapsed}s\n".encode("utf-8"))
+                next_heartbeat = time.monotonic() + heartbeat_seconds
+            if proc.poll() is None and seen_agent_progress and time.monotonic() >= next_heartbeat:
+                elapsed = int(time.monotonic() - started_at)
+                idle_for = int(time.monotonic() - last_agent_progress_at)
+                write_running_heartbeat()
+                log_handle.write(
+                    f"[openclaw] heartbeat progress source={last_progress_source} elapsed={elapsed}s idle={idle_for}s\n".encode("utf-8")
+                )
+                next_heartbeat = time.monotonic() + heartbeat_seconds
             if proc.poll() is not None:
                 break
             continue
@@ -831,6 +1094,10 @@ with open(output_path, "ab", buffering=0) as log_handle:
             log_handle.write(chunk)
             text = chunk.decode("utf-8", errors="replace")
             tail = (tail + text)[-8192:]
+            next_heartbeat = time.monotonic() + heartbeat_seconds
+            seen_agent_progress = True
+            last_agent_progress_at = time.monotonic()
+            last_progress_source = "stdout"
 
             if not matched_terminal_error and any(pattern.search(tail) for pattern in terminal_patterns):
                 matched_terminal_error = True
@@ -950,9 +1217,9 @@ while true; do
   break
 done
 recover_literal_runtime_artifacts
+infer_result_from_output
+synthesize_comment_artifact_from_output
 if [[ "\${status}" -eq 0 ]]; then
-  # Infer result.env from output if agent didn't create one
-  infer_result_from_output
   write_state succeeded "0" ""
 else
   if [[ -z "\${failure_reason}" ]]; then

package/tools/bin/agent-project-sync-anchor-repo

@@ -16,6 +16,8 @@ canonical_root=""
 anchor_root=""
 remote_name="origin"
 default_branch="main"
+dirty_state_stashed="no"
+dirty_stash_message=""
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
@@ -103,8 +105,13 @@ git -C "$anchor_root" fetch "$remote_name" --prune >/dev/null
 git -C "$anchor_root" worktree prune >/dev/null 2>&1 || true
 
 if [[ -n "$(git -C "$anchor_root" status --porcelain --untracked-files=no)" ]]; then
-  echo "[agent-sync-anchor] anchor repo is dirty; refuse to reset: $anchor_root" >&2
-  exit 1
+  dirty_stash_message="acp-anchor-sync-$(date -u +%Y%m%dT%H%M%SZ)"
+  git -C "$anchor_root" stash push --message "$dirty_stash_message" >/dev/null
+  if [[ -n "$(git -C "$anchor_root" status --porcelain --untracked-files=no)" ]]; then
+    echo "[agent-sync-anchor] anchor repo is dirty; refuse to reset: $anchor_root" >&2
+    exit 1
+  fi
+  dirty_state_stashed="yes"
 fi
 
 default_ref="${remote_name}/${default_branch}"
@@ -126,3 +133,7 @@ printf 'ANCHOR_ROOT=%s\n' "$anchor_root"
 printf 'REMOTE=%s\n' "$remote_name"
 printf 'DEFAULT_BRANCH=%s\n' "$default_branch"
 printf 'ORIGIN_URL=%s\n' "$origin_url"
+printf 'DIRTY_STATE_STASHED=%s\n' "$dirty_state_stashed"
+if [[ "$dirty_state_stashed" == "yes" ]]; then
+  printf 'DIRTY_STASH_MESSAGE=%s\n' "$dirty_stash_message"
+fi

package/tools/bin/agent-project-worker-status

@@ -87,23 +87,14 @@ if [[ "$status" == "UNKNOWN" && -f "$output_file" ]]; then
   fi
 fi
 
-if [[ "$status" == "UNKNOWN" && -f "$result_file" ]]; then
-  # A worker that managed to persist result.env already completed its contract,
-  # even if the tmux session disappeared before the exit marker was flushed.
-  status="SUCCEEDED"
-  result_only_completion="yes"
-fi
-
-if [[ "$status" == "UNKNOWN" && -f "$output_file" ]]; then
-  if rg -qi "You've hit your usage limit|You have reached your Codex usage limits|visit https://chatgpt.com/codex/settings/usage|Upgrade to Pro|rate limit exceeded|quota exceeded|usage cap (reached|exceeded)|usage quota (reached|exceeded)" "$output_file"; then
-    status="FAILED"
-    failure_reason="usage-limit"
-  fi
-fi
-
 if [[ "$status" == "UNKNOWN" && -n "$runner_state" ]]; then
   case "$runner_state" in
     running|waiting-auth-refresh|switching-account)
+      # Tmux session is gone and runner never reached a terminal state.
+      # This detects crashes where the worker process died before updating
+      # runner.env or writing an exit marker.
+      # Check BEFORE stale result.env to avoid false SUCCEEDED when a prior
+      # cycle's result.env happens to exist.
       status="FAILED"
       if [[ -z "$failure_reason" ]]; then
         failure_reason="runner-aborted-before-completion"
@@ -115,6 +106,20 @@ if [[ "$status" == "UNKNOWN" && -n "$runner_state" ]]; then
   esac
 fi
 
+if [[ "$status" == "UNKNOWN" && -f "$result_file" ]]; then
+  # A worker that managed to persist result.env already completed its contract,
+  # even if the tmux session disappeared before the exit marker was flushed.
+  status="SUCCEEDED"
+  result_only_completion="yes"
+fi
+
+if [[ "$status" == "UNKNOWN" && -f "$output_file" ]]; then
+  if rg -qi "You've hit your usage limit|You have reached your Codex usage limits|visit https://chatgpt.com/codex/settings/usage|Upgrade to Pro|rate limit exceeded|quota exceeded|usage cap (reached|exceeded)|usage quota (reached|exceeded)" "$output_file"; then
+    status="FAILED"
+    failure_reason="usage-limit"
+  fi
+fi
+
 printf 'SESSION=%s\n' "$session"
 printf 'STATUS=%s\n' "$status"
 if [[ -f "$meta_file" ]]; then

package/tools/bin/cleanup-worktree.sh

@@ -12,6 +12,7 @@ AGENT_REPO_ROOT="$(flow_resolve_agent_repo_root "${CONFIG_YAML}")"
 AGENT_ROOT="$(flow_resolve_agent_root "${CONFIG_YAML}")"
 RUNS_ROOT="$(flow_resolve_runs_root "${CONFIG_YAML}")"
 HISTORY_ROOT="$(flow_resolve_history_root "${CONFIG_YAML}")"
+WORKTREE_ROOT="$(flow_resolve_worktree_root "${CONFIG_YAML}")"
 RETAINED_REPO_ROOT="$(flow_resolve_retained_repo_root "${CONFIG_YAML}")"
 VSCODE_WORKSPACE_FILE="$(flow_resolve_vscode_workspace_file "${CONFIG_YAML}")"
 ISSUE_SESSION_PREFIX="$(flow_resolve_issue_session_prefix "${CONFIG_YAML}")"
@@ -36,7 +37,9 @@ if [[ -n "$SESSION" ]]; then
   ARGS+=(--session "$SESSION")
 fi
 
-bash "${FLOW_TOOLS_DIR}/agent-project-cleanup-session" "${ARGS[@]}" >/dev/null
+AGENT_PROJECT_WORKTREE_ROOT="$WORKTREE_ROOT" \
+F_LOSNING_WORKTREE_ROOT="$WORKTREE_ROOT" \
+  bash "${FLOW_TOOLS_DIR}/agent-project-cleanup-session" "${ARGS[@]}" >/dev/null
 
 F_LOSNING_AGENT_REPO_ROOT="$AGENT_REPO_ROOT" \
 F_LOSNING_RETAINED_REPO_ROOT="$RETAINED_REPO_ROOT" \

package/tools/bin/dashboard-launchd-bootstrap.sh

@@ -4,13 +4,14 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 FLOW_SKILL_DIR="$(cd "${SCRIPT_DIR}/../.." && pwd)"
 HOME_DIR="${ACP_DASHBOARD_HOME_DIR:-${HOME:-}}"
-SOURCE_HOME="${ACP_DASHBOARD_SOURCE_HOME:-$(cd "${FLOW_SKILL_DIR}/../../.." && pwd)}"
+SOURCE_HOME="${ACP_DASHBOARD_SOURCE_HOME:-}"
 RUNTIME_HOME="${ACP_DASHBOARD_RUNTIME_HOME:-${HOME_DIR}/.agent-runtime/runtime-home}"
 PROFILE_REGISTRY_ROOT="${ACP_DASHBOARD_PROFILE_REGISTRY_ROOT:-${ACP_PROFILE_REGISTRY_ROOT:-${HOME_DIR}/.agent-runtime/control-plane/profiles}}"
 HOST="${ACP_DASHBOARD_HOST:-127.0.0.1}"
 PORT="${ACP_DASHBOARD_PORT:-8765}"
 BASE_PATH="${ACP_DASHBOARD_PATH:-/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin}"
 SYNC_SCRIPT="${ACP_DASHBOARD_SYNC_SCRIPT:-${FLOW_SKILL_DIR}/tools/bin/sync-shared-agent-home.sh}"
+ENSURE_SYNC_SCRIPT="${ACP_DASHBOARD_ENSURE_SYNC_SCRIPT:-${FLOW_SKILL_DIR}/tools/bin/ensure-runtime-sync.sh}"
 RUNTIME_SERVE_SCRIPT="${ACP_DASHBOARD_RUNTIME_SERVE_SCRIPT:-${RUNTIME_HOME}/skills/openclaw/agent-control-plane/tools/bin/serve-dashboard.sh}"
 
 if [[ -z "${HOME_DIR}" ]]; then
@@ -23,12 +24,23 @@ export PATH="${BASE_PATH}"
 export ACP_PROFILE_REGISTRY_ROOT="${PROFILE_REGISTRY_ROOT}"
 export PYTHONDONTWRITEBYTECODE=1
 
-if [[ ! -x "${SYNC_SCRIPT}" ]]; then
-  echo "dashboard launchd bootstrap missing sync script: ${SYNC_SCRIPT}" >&2
+if [[ ! -x "${ENSURE_SYNC_SCRIPT}" && ! -x "${SYNC_SCRIPT}" ]]; then
+  echo "dashboard launchd bootstrap missing sync helper: ${ENSURE_SYNC_SCRIPT}" >&2
   exit 65
 fi
 
-bash "${SYNC_SCRIPT}" "${SOURCE_HOME}" "${RUNTIME_HOME}" >/dev/null
+if [[ -x "${ENSURE_SYNC_SCRIPT}" ]]; then
+  ensure_args=(--runtime-home "${RUNTIME_HOME}" --quiet)
+  if [[ -n "${SOURCE_HOME}" ]]; then
+    ensure_args=(--source-home "${SOURCE_HOME}" "${ensure_args[@]}")
+  fi
+  bash "${ENSURE_SYNC_SCRIPT}" "${ensure_args[@]}"
+else
+  if [[ -z "${SOURCE_HOME}" ]]; then
+    SOURCE_HOME="${FLOW_SKILL_DIR}"
+  fi
+  bash "${SYNC_SCRIPT}" "${SOURCE_HOME}" "${RUNTIME_HOME}" >/dev/null
+fi
 
 if [[ ! -x "${RUNTIME_SERVE_SCRIPT}" ]]; then
   echo "dashboard launchd bootstrap missing runtime serve script: ${RUNTIME_SERVE_SCRIPT}" >&2