agent-control-plane 0.1.8 → 0.1.9

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,13 @@ 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_output = False
+last_agent_output_at = started_at
 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),
@@ -780,6 +933,25 @@ sel = selectors.DefaultSelector()
 matched_terminal_error = False
 tail = ""
 
+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:
         os.killpg(process.pid, signal.SIGTERM)
@@ -819,6 +991,24 @@ with open(output_path, "ab", buffering=0) as log_handle:
 
         events = sel.select(timeout=0.2)
         if not events:
+            if proc.poll() is None and not seen_agent_output 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_output and stall_seconds > 0 and (time.monotonic() - last_agent_output_at) >= stall_seconds:
+                elapsed = int(time.monotonic() - started_at)
+                idle_for = int(time.monotonic() - last_agent_output_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 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 not None:
                 break
             continue
@@ -831,6 +1021,9 @@ 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_output = True
+            last_agent_output_at = time.monotonic()
 
             if not matched_terminal_error and any(pattern.search(tail) for pattern in terminal_patterns):
                 matched_terminal_error = True
@@ -950,9 +1143,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/flow-shell-lib.sh

@@ -144,6 +144,7 @@ flow_print_dir() {
 resolve_flow_skill_dir() {
   local script_path="${1:-}"
   local candidate=""
+  local search_dir=""
   local skill_name=""
 
   for candidate in \
@@ -158,13 +159,18 @@ resolve_flow_skill_dir() {
   done
 
   if [[ -n "${script_path}" ]]; then
-    candidate="$(
-      cd "$(dirname "${script_path}")/../.." 2>/dev/null && pwd -P
-    )" || candidate=""
-    if flow_is_skill_root "${candidate}"; then
-      printf '%s\n' "${candidate}"
-      return 0
-    fi
+    search_dir="$(
+      cd "$(dirname "${script_path}")" 2>/dev/null && pwd -P
+    )" || search_dir=""
+    while [[ -n "${search_dir}" && "${search_dir}" != "/" ]]; do
+      if flow_is_skill_root "${search_dir}"; then
+        printf '%s\n' "${search_dir}"
+        return 0
+      fi
+      candidate="$(dirname "${search_dir}")"
+      [[ "${candidate}" != "${search_dir}" ]] || break
+      search_dir="${candidate}"
+    done
   fi
 
   if [[ -n "${SHARED_AGENT_HOME:-}" ]]; then

package/tools/bin/prepare-worktree.sh

@@ -119,7 +119,9 @@ mkdir -p "$WORKTREE/.openclaw-artifacts"
 configure_worktree_excludes "$WORKTREE"
 
 if [[ -x "$SYNC_DEPENDENCY_BASELINE_SCRIPT" && "$DEPENDENCY_REAL" == "$CANONICAL_REAL" ]]; then
-  "$SYNC_DEPENDENCY_BASELINE_SCRIPT" >/dev/null
+  # Sync dependency baseline is non-fatal — worker can function without it
+  # (especially for repos with zero dependencies or external volume issues)
+  "$SYNC_DEPENDENCY_BASELINE_SCRIPT" >/dev/null 2>&1 || true
 fi
 
 if [[ "$LOCAL_WORKSPACE_INSTALL" == "true" ]]; then

package/tools/bin/provider-cooldown-state.sh

@@ -12,7 +12,7 @@ Usage:
 
 Examples:
   provider-cooldown-state.sh get
-  provider-cooldown-state.sh openclaw openrouter/stepfun/step-3.5-flash:free schedule provider-quota-limit
+  provider-cooldown-state.sh openclaw openrouter/qwen/qwen3.6-plus-preview:free schedule provider-quota-limit
 EOF
 }
 

package/tools/bin/render-flow-config.sh

@@ -8,7 +8,22 @@ source "${SCRIPT_DIR}/flow-config-lib.sh"
 FLOW_SKILL_DIR="$(resolve_flow_skill_dir "${BASH_SOURCE[0]}")"
 PROFILE_REGISTRY_ROOT="$(resolve_flow_profile_registry_root)"
 CONFIG_YAML="$(resolve_flow_config_yaml "${BASH_SOURCE[0]}")"
-flow_export_execution_env "${CONFIG_YAML}"
+# Do NOT export execution env for the current profile here — render-flow-config
+# is meant to render the SELECTED profile's config (via CONFIG_YAML), and exporting
+# the ambient profile's vars into the shell causes config_or_env to silently override
+# per-profile YAML with defaults from the current resident worker's own config.
+# Also, ambient env vars from the shell are cleared below so they don't leak into
+# profile-smoke or other callers.
+for _clean in ACP_CODING_WORKER ACP_OPENCLAW_MODEL ACP_CLAUDE_MODEL \
+  ACP_CLAUDE_TIMEOUT_SECONDS ACP_CLAUDE_MAX_ATTEMPTS ACP_CLAUDE_RETRY_BACKOFF_SECONDS \
+  ACP_OPENCLAW_THINKING ACP_OPENCLAW_TIMEOUT_SECONDS \
+  F_LOSNING_CODING_WORKER F_LOSNING_OPENCLAW_MODEL F_LOSNING_CLAUDE_MODEL \
+  F_LOSNING_CLAUDE_TIMEOUT_SECONDS F_LOSNING_CLAUDE_MAX_ATTEMPTS F_LOSNING_CLAUDE_RETRY_BACKOFF_SECONDS \
+  F_LOSNING_OPENCLAW_THINKING F_LOSNING_OPENCLAW_TIMEOUT_SECONDS \
+  CODING_WORKER; do
+  unset "${_clean}" 2>/dev/null || true
+done
+unset _clean
 AVAILABLE_PROFILES="$(flow_list_profile_ids "${FLOW_SKILL_DIR}" | paste -sd, -)"
 INSTALLED_PROFILES="$(flow_list_installed_profile_ids | paste -sd, -)"
 PROFILE_ID="$(flow_resolve_adapter_id "${CONFIG_YAML}")"

package/tools/bin/run-codex-task.sh

@@ -61,8 +61,8 @@ RESIDENT_OPENCLAW_AGENT_DIR="${ACP_RESIDENT_OPENCLAW_AGENT_DIR:-${F_LOSNING_RESI
 RESIDENT_OPENCLAW_STATE_DIR="${ACP_RESIDENT_OPENCLAW_STATE_DIR:-${F_LOSNING_RESIDENT_OPENCLAW_STATE_DIR:-}}"
 RESIDENT_OPENCLAW_CONFIG_PATH="${ACP_RESIDENT_OPENCLAW_CONFIG_PATH:-${F_LOSNING_RESIDENT_OPENCLAW_CONFIG_PATH:-}}"
 # Set defaults if not set from yaml or env
-OPENCLAW_MODEL="${OPENCLAW_MODEL:-${ACP_OPENCLAW_MODEL:-${F_LOSNING_OPENCLAW_MODEL:-openrouter/stepfun/step-3.5-flash:free}}}"
-OPENCLAW_THINKING="${OPENCLAW_THINKING:-${ACP_OPENCLAW_THINKING:-${F_LOSNING_OPENCLAW_THINKING:-adaptive}}}"
+OPENCLAW_MODEL="${OPENCLAW_MODEL:-${ACP_OPENCLAW_MODEL:-${F_LOSNING_OPENCLAW_MODEL:-openrouter/qwen/qwen3.6-plus-preview:free}}}"
+OPENCLAW_THINKING="${OPENCLAW_THINKING:-${ACP_OPENCLAW_THINKING:-${F_LOSNING_OPENCLAW_THINKING:-low}}}"
 OPENCLAW_TIMEOUT_SECONDS="${OPENCLAW_TIMEOUT_SECONDS:-${ACP_OPENCLAW_TIMEOUT_SECONDS:-${F_LOSNING_OPENCLAW_TIMEOUT_SECONDS:-900}}}"
 printf -v SESSION_Q '%q' "$SESSION"
 printf -v CONFIG_YAML_Q '%q' "$CONFIG_YAML"

package/tools/bin/scaffold-profile.sh

@@ -54,8 +54,8 @@ claude_effort="medium"
 claude_timeout_seconds="900"
 claude_max_attempts="3"
 claude_retry_backoff_seconds="30"
-openclaw_model="openrouter/stepfun/step-3.5-flash:free"
-openclaw_thinking="minimal"
+openclaw_model="openrouter/qwen/qwen3.6-plus-preview:free"
+openclaw_thinking="low"
 openclaw_timeout_seconds="600"
 force="0"
 

package/tools/bin/start-issue-worker.sh

@@ -386,6 +386,38 @@ const blockerComment = [...(issue.comments || [])]
     ),
   );
 
+const inferCommentReason = (bodyText) => {
+  const body = String(bodyText || '');
+  const marker = 'Failure reason:';
+  const markerIndex = body.search(/Failure reason:/i);
+  if (markerIndex !== -1) {
+    const backtick = String.fromCharCode(96);
+    const tail = body.slice(markerIndex + marker.length);
+    const firstQuoted = tail.split(backtick)[1];
+    if (firstQuoted) {
+      return firstQuoted.trim();
+    }
+  }
+  if (/^# Blocker: Verification requirements were not satisfied$/im.test(body)) {
+    return 'verification-guard-blocked';
+  }
+  if (/^# Blocker: (All checklist items already completed|Worker produced no publishable delta)$/im.test(body)) {
+    return 'no-publishable-commits';
+  }
+  if (/scope guard/i.test(body)) {
+    return 'scope-guard-blocked';
+  }
+  if (/^# Blocker: Provider quota is currently exhausted$/im.test(body)) {
+    return 'provider-quota-limit';
+  }
+  return '';
+};
+
+const effectiveLastReason =
+  lastReason && lastReason !== 'issue-worker-blocked'
+    ? lastReason
+    : inferCommentReason(blockerComment?.body || '') || lastReason;
+
 if (!blockerComment || !blockerComment.body) {
   const fallbackLines = [
     '',
@@ -393,13 +425,13 @@ if (!blockerComment || !blockerComment.body) {
     'This issue is being retried after an `agent-blocked` stop.',
     '- First resolve the prior blocker instead of repeating the same broad implementation path.',
   ];
-  if (lastReason) {
-    fallbackLines.push(`- Last recorded blocker: \`${lastReason}\`.`);
+  if (effectiveLastReason) {
+    fallbackLines.push('- Last recorded blocker: `' + effectiveLastReason + '`.');
   }
   if (attempts > 0) {
-    fallbackLines.push(`- Blocked retries so far: ${attempts}.`);
+    fallbackLines.push('- Blocked retries so far: ' + attempts + '.');
   }
-  if (lastReason === 'scope-guard-blocked' && attempts >= 2) {
+  if (effectiveLastReason === 'scope-guard-blocked' && attempts >= 2) {
     fallbackLines.push(
       '- This issue has already hit the scope guard multiple times. Do not attempt another broad multi-surface patch.',
       `- Either ship one focused slice that stays under the scope guard, or create focused follow-up issues with \`bash "$FLOW_TOOLS_DIR/create-follow-up-issue.sh" --parent ${issue.number} --title "..." --body-file /tmp/follow-up.md\` and supersede the umbrella.`,
@@ -420,21 +452,21 @@ const lines = [
   '- Address the blocker below before attempting a new implementation/publish cycle.',
 ];
 
-if (lastReason) {
-  lines.push(`- Last recorded blocker: \`${lastReason}\`.`);
+if (effectiveLastReason) {
+  lines.push('- Last recorded blocker: `' + effectiveLastReason + '`.');
 }
 if (attempts > 0) {
-  lines.push(`- Blocked retries so far: ${attempts}.`);
+  lines.push('- Blocked retries so far: ' + attempts + '.');
 }
 if (nextAttemptAt) {
-  lines.push(`- Last scheduled retry target was ${nextAttemptAt}.`);
+  lines.push('- Last scheduled retry target was ' + nextAttemptAt + '.');
 }
-if (lastReason === 'scope-guard-blocked') {
+if (effectiveLastReason === 'scope-guard-blocked') {
   lines.push('- Treat this as a scope problem first: narrow to one safe slice or decompose into focused follow-up issues.');
   if (attempts >= 2) {
     lines.push(`- Because the scope guard has already fired multiple times, do not retry the same umbrella patch. Use \`bash "$FLOW_TOOLS_DIR/create-follow-up-issue.sh" --parent ${issue.number} --title "..." --body-file /tmp/follow-up.md\` for the remaining slices, then supersede the umbrella if you covered the full decomposition.`);
   }
-} else if (lastReason === 'verification-guard-blocked') {
+} else if (effectiveLastReason === 'verification-guard-blocked') {
   lines.push('- Add the missing verification or shrink the touched surface before attempting another publish cycle.');
 }