agent-control-plane 0.3.0 → 0.6.0

package/tools/bin/retry-state.sh

@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=/dev/null
-source "${SCRIPT_DIR}/flow-shell-lib.sh"
-# shellcheck source=/dev/null
-source "${SCRIPT_DIR}/flow-config-lib.sh"
-
-KIND="${1:?usage: retry-state.sh issue|pr ID get|schedule|clear [reason]}"
-ITEM_ID="${2:?usage: retry-state.sh issue|pr ID get|schedule|clear [reason]}"
-ACTION="${3:?usage: retry-state.sh issue|pr ID get|schedule|clear [reason]}"
-REASON="${4:-}"
-
-CONFIG_YAML="$(resolve_flow_config_yaml "${BASH_SOURCE[0]}")"
-AGENT_ROOT="$(flow_resolve_agent_root "${CONFIG_YAML}")"
-STATE_ROOT="$(flow_resolve_state_root "${CONFIG_YAML}")"
-COOLDOWNS="$(flow_resolve_retry_cooldowns "${CONFIG_YAML}")"
-FLOW_SKILL_DIR="$(resolve_flow_skill_dir "${BASH_SOURCE[0]}")"
-FLOW_TOOLS_DIR="${FLOW_SKILL_DIR}/tools/bin"
-
-ACP_AGENT_ROOT="$AGENT_ROOT" \
-ACP_STATE_ROOT="$STATE_ROOT" \
-ACP_RETRY_COOLDOWNS="$COOLDOWNS" \
-exec bash "${FLOW_TOOLS_DIR}/agent-project-retry-state" \
-  --state-root "$STATE_ROOT" \
-  --kind "$KIND" \
-  --item-id "$ITEM_ID" \
-  --action "$ACTION" \
-  --reason "$REASON" \
-  --cooldowns "$COOLDOWNS"

package/tools/bin/reuse-issue-worktree.sh

@@ -1,121 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=/dev/null
-source "${SCRIPT_DIR}/flow-config-lib.sh"
-
-usage() {
-  cat <<'EOF'
-Usage:
-  reuse-issue-worktree.sh WORKTREE ISSUE_ID [SLUG]
-
-Reset and re-branch an existing managed issue worktree so a recurring issue can
-reuse the same workspace path across multiple cycles.
-EOF
-}
-
-WORKTREE="${1:-}"
-ISSUE_ID="${2:-}"
-SLUG_INPUT="${3:-task}"
-
-if [[ -z "${WORKTREE}" || -z "${ISSUE_ID}" ]]; then
-  usage >&2
-  exit 1
-fi
-
-FLOW_SKILL_DIR="$(resolve_flow_skill_dir "${BASH_SOURCE[0]}")"
-if ! flow_require_explicit_profile_selection "${FLOW_SKILL_DIR}" "reuse-issue-worktree.sh"; then
-  exit 64
-fi
-
-CONFIG_YAML="$(resolve_flow_config_yaml "${BASH_SOURCE[0]}")"
-AGENT_REPO_ROOT="$(flow_resolve_agent_repo_root "${CONFIG_YAML}")"
-WORKTREE_ROOT="$(flow_resolve_worktree_root "${CONFIG_YAML}")"
-ISSUE_BRANCH_PREFIX="$(flow_resolve_issue_branch_prefix "${CONFIG_YAML}")"
-DEFAULT_BRANCH="$(flow_resolve_default_branch "${CONFIG_YAML}")"
-BASE_REF="origin/${DEFAULT_BRANCH}"
-PREPARE_SCRIPT="${SCRIPT_DIR}/prepare-worktree.sh"
-
-safe_slug="$(printf '%s' "${SLUG_INPUT}" | tr '[:upper:]' '[:lower:]' | tr -cs 'a-z0-9' '-')"
-safe_slug="${safe_slug#-}"
-safe_slug="${safe_slug%-}"
-if [[ -z "${safe_slug}" ]]; then
-  safe_slug="task"
-fi
-
-stamp="$(date +%Y%m%d-%H%M%S)"
-branch_name="${ISSUE_BRANCH_PREFIX}-${ISSUE_ID}-${safe_slug}-${stamp}"
-previous_branch="$(git -C "${WORKTREE}" branch --show-current 2>/dev/null || true)"
-resolved_worktree=""
-actual_branch=""
-rotated_worktree=""
-
-if ! git -C "${WORKTREE}" rev-parse --git-dir >/dev/null 2>&1; then
-  echo "invalid managed worktree: ${WORKTREE}" >&2
-  exit 1
-fi
-
-git -C "${AGENT_REPO_ROOT}" fetch \
-  origin \
-  "+refs/heads/${DEFAULT_BRANCH}:refs/remotes/origin/${DEFAULT_BRANCH}" \
-  --prune >/dev/null
-
-# Reset the resident workspace to the latest baseline before switching to the
-# next focused cycle branch.
-git -C "${WORKTREE}" reset --hard >/dev/null
-git -C "${WORKTREE}" clean -fd >/dev/null
-git -C "${WORKTREE}" checkout -B "${branch_name}" "${BASE_REF}" >/dev/null
-
-if [[ -n "${previous_branch}" && "${previous_branch}" != "${branch_name}" ]]; then
-  git -C "${AGENT_REPO_ROOT}" branch -D "${previous_branch}" >/dev/null 2>&1 || true
-fi
-
-"${PREPARE_SCRIPT}" "${WORKTREE}" >/dev/null
-
-if ! git -C "${WORKTREE}" rev-parse --git-dir >/dev/null 2>&1; then
-  echo "invalid managed worktree after reuse: ${WORKTREE}" >&2
-  exit 1
-fi
-
-resolved_worktree="$(cd "${WORKTREE}" 2>/dev/null && pwd -P || true)"
-if [[ -z "${resolved_worktree}" || ! -d "${resolved_worktree}" ]]; then
-  echo "reused worktree path is unavailable: ${WORKTREE}" >&2
-  exit 1
-fi
-WORKTREE="${resolved_worktree}"
-
-if [[ -n "${WORKTREE_ROOT}" ]]; then
-  mkdir -p "${WORKTREE_ROOT}"
-  rotated_worktree="${WORKTREE_ROOT}/issue-${ISSUE_ID}-${stamp}"
-  if [[ "${resolved_worktree}" != "${rotated_worktree}" ]]; then
-    if [[ -e "${rotated_worktree}" ]]; then
-      echo "rotated worktree path already exists: ${rotated_worktree}" >&2
-      exit 1
-    fi
-    git -C "${AGENT_REPO_ROOT}" worktree move "${resolved_worktree}" "${rotated_worktree}" >/dev/null
-    WORKTREE="${rotated_worktree}"
-    resolved_worktree="$(cd "${WORKTREE}" 2>/dev/null && pwd -P || true)"
-    if [[ -z "${resolved_worktree}" || ! -d "${resolved_worktree}" ]]; then
-      echo "rotated worktree path is unavailable: ${WORKTREE}" >&2
-      exit 1
-    fi
-    WORKTREE="${resolved_worktree}"
-  fi
-fi
-
-if ! git -C "${AGENT_REPO_ROOT}" worktree list --porcelain | grep -Fqx "worktree ${resolved_worktree}"; then
-  echo "reused worktree is no longer registered: ${resolved_worktree}" >&2
-  exit 1
-fi
-
-actual_branch="$(git -C "${WORKTREE}" branch --show-current 2>/dev/null || true)"
-if [[ -z "${actual_branch}" || "${actual_branch}" != "${branch_name}" ]]; then
-  echo "reused worktree branch mismatch: expected ${branch_name} got ${actual_branch:-<none>}" >&2
-  exit 1
-fi
-
-printf 'WORKTREE=%s\n' "${WORKTREE}"
-printf 'BRANCH=%s\n' "${branch_name}"
-printf 'BASE_REF=%s\n' "${BASE_REF}"
-printf 'REUSED=yes\n'

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

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-"$(dirname "$0")/run-codex-task.sh" bypass "$@"

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

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-"$(dirname "$0")/run-codex-task.sh" safe "$@"

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

@@ -1,280 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=/dev/null
-source "${SCRIPT_DIR}/flow-config-lib.sh"
-
-MODE="${1:?usage: run-codex-task.sh MODE SESSION WORKTREE PROMPT_FILE}"
-SESSION="${2:?usage: run-codex-task.sh MODE SESSION WORKTREE PROMPT_FILE}"
-WORKTREE="${3:?usage: run-codex-task.sh MODE SESSION WORKTREE PROMPT_FILE}"
-PROMPT_FILE="${4:?usage: run-codex-task.sh MODE SESSION WORKTREE PROMPT_FILE}"
-
-WORKSPACE_DIR="$(cd "$(dirname "$0")/.." && pwd)"
-CONFIG_YAML="$(resolve_flow_config_yaml "${BASH_SOURCE[0]}")"
-flow_export_execution_env "${CONFIG_YAML}"
-flow_export_project_env_aliases
-AGENT_ROOT="$(flow_resolve_agent_root "${CONFIG_YAML}")"
-RUNS_ROOT="$(flow_resolve_runs_root "${CONFIG_YAML}")"
-AGENT_REPO_ROOT="$(flow_resolve_agent_repo_root "${CONFIG_YAML}")"
-CANONICAL_REPO_ROOT="$(flow_resolve_repo_root "${CONFIG_YAML}")"
-WORKTREE_ROOT="$(flow_resolve_worktree_root "${CONFIG_YAML}")"
-DEPENDENCY_SOURCE_ROOT="${ACP_DEPENDENCY_SOURCE_ROOT:-${F_LOSNING_DEPENDENCY_SOURCE_ROOT:-$CANONICAL_REPO_ROOT}}"
-RETAINED_REPO_ROOT="$(flow_resolve_retained_repo_root "${CONFIG_YAML}")"
-ISSUE_ID="${ACP_ISSUE_ID:-${F_LOSNING_ISSUE_ID:-}}"
-ISSUE_URL="${ACP_ISSUE_URL:-${F_LOSNING_ISSUE_URL:-}}"
-ISSUE_AUTOMERGE="${ACP_ISSUE_AUTOMERGE:-${F_LOSNING_ISSUE_AUTOMERGE:-no}}"
-PR_NUMBER="${ACP_PR_NUMBER:-${F_LOSNING_PR_NUMBER:-}}"
-PR_URL="${ACP_PR_URL:-${F_LOSNING_PR_URL:-}}"
-PR_HEAD_REF="${ACP_PR_HEAD_REF:-${F_LOSNING_PR_HEAD_REF:-}}"
-FLOW_SKILL_DIR="$(resolve_flow_skill_dir "${BASH_SOURCE[0]}")"
-FLOW_TOOLS_DIR="${FLOW_SKILL_DIR}/tools/bin"
-TASK_KIND="task"
-TASK_ID="$SESSION"
-RECONCILE_COMMAND=""
-ADAPTER_ID="$(flow_resolve_adapter_id "${CONFIG_YAML}")"
-ISSUE_SESSION_PREFIX="$(flow_resolve_issue_session_prefix "${CONFIG_YAML}")"
-PR_SESSION_PREFIX="$(flow_resolve_pr_session_prefix "${CONFIG_YAML}")"
-CODING_WORKER="${ACP_CODING_WORKER:-codex}"
-CODEX_PROFILE_SAFE="${ACP_CODEX_PROFILE_SAFE:-${F_LOSNING_CODEX_PROFILE_SAFE:-${CODEX_PROFILE_SAFE:-f_losning_safe_auto}}}"
-CODEX_PROFILE_BYPASS="${ACP_CODEX_PROFILE_BYPASS:-${F_LOSNING_CODEX_PROFILE_BYPASS:-${CODEX_PROFILE_BYPASS:-f_losning_yolo}}}"
-if [[ "$MODE" == "bypass" ]]; then
-  CLAUDE_PERMISSION_MODE_DEFAULT="bypassPermissions"
-else
-  CLAUDE_PERMISSION_MODE_DEFAULT="acceptEdits"
-fi
-CLAUDE_MODEL="${ACP_CLAUDE_MODEL:-${F_LOSNING_CLAUDE_MODEL:-sonnet}}"
-CLAUDE_PERMISSION_MODE="${ACP_CLAUDE_PERMISSION_MODE:-${F_LOSNING_CLAUDE_PERMISSION_MODE:-${CLAUDE_PERMISSION_MODE_DEFAULT}}}"
-CLAUDE_EFFORT="${ACP_CLAUDE_EFFORT:-${F_LOSNING_CLAUDE_EFFORT:-medium}}"
-CLAUDE_TIMEOUT_SECONDS="${ACP_CLAUDE_TIMEOUT_SECONDS:-${F_LOSNING_CLAUDE_TIMEOUT_SECONDS:-900}}"
-CLAUDE_MAX_ATTEMPTS="${ACP_CLAUDE_MAX_ATTEMPTS:-${F_LOSNING_CLAUDE_MAX_ATTEMPTS:-3}}"
-CLAUDE_RETRY_BACKOFF_SECONDS="${ACP_CLAUDE_RETRY_BACKOFF_SECONDS:-${F_LOSNING_CLAUDE_RETRY_BACKOFF_SECONDS:-30}}"
-RESIDENT_WORKER_ENABLED="${ACP_RESIDENT_WORKER_ENABLED:-${F_LOSNING_RESIDENT_WORKER_ENABLED:-}}"
-RESIDENT_WORKER_KEY="${ACP_RESIDENT_WORKER_KEY:-${F_LOSNING_RESIDENT_WORKER_KEY:-}}"
-RESIDENT_WORKER_DIR="${ACP_RESIDENT_WORKER_DIR:-${F_LOSNING_RESIDENT_WORKER_DIR:-}}"
-RESIDENT_WORKER_META_FILE="${ACP_RESIDENT_WORKER_META_FILE:-${F_LOSNING_RESIDENT_WORKER_META_FILE:-}}"
-RESIDENT_TASK_COUNT="${ACP_RESIDENT_TASK_COUNT:-${F_LOSNING_RESIDENT_TASK_COUNT:-}}"
-RESIDENT_WORKTREE_REUSED="${ACP_RESIDENT_WORKTREE_REUSED:-${F_LOSNING_RESIDENT_WORKTREE_REUSED:-}}"
-RESIDENT_OPENCLAW_AGENT_ID="${ACP_RESIDENT_OPENCLAW_AGENT_ID:-${F_LOSNING_RESIDENT_OPENCLAW_AGENT_ID:-}}"
-RESIDENT_OPENCLAW_SESSION_ID="${ACP_RESIDENT_OPENCLAW_SESSION_ID:-${F_LOSNING_RESIDENT_OPENCLAW_SESSION_ID:-}}"
-RESIDENT_OPENCLAW_AGENT_DIR="${ACP_RESIDENT_OPENCLAW_AGENT_DIR:-${F_LOSNING_RESIDENT_OPENCLAW_AGENT_DIR:-}}"
-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/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}}}"
-OLLAMA_MODEL="${ACP_OLLAMA_MODEL:-${F_LOSNING_OLLAMA_MODEL:-qwen2.5-coder:7b}}"
-OLLAMA_BASE_URL="${ACP_OLLAMA_BASE_URL:-${F_LOSNING_OLLAMA_BASE_URL:-http://localhost:11434}}"
-OLLAMA_TIMEOUT_SECONDS="${ACP_OLLAMA_TIMEOUT_SECONDS:-${F_LOSNING_OLLAMA_TIMEOUT_SECONDS:-900}}"
-PI_MODEL="${ACP_PI_MODEL:-${F_LOSNING_PI_MODEL:-openrouter/qwen/qwen3.6-plus:free}}"
-PI_THINKING="${ACP_PI_THINKING:-${F_LOSNING_PI_THINKING:-low}}"
-PI_TIMEOUT_SECONDS="${ACP_PI_TIMEOUT_SECONDS:-${F_LOSNING_PI_TIMEOUT_SECONDS:-900}}"
-PI_STALL_SECONDS="${ACP_PI_STALL_SECONDS:-${F_LOSNING_PI_STALL_SECONDS:-300}}"
-OPENCODE_MODEL="${ACP_OPENCODE_MODEL:-${F_LOSNING_OPENCODE_MODEL:-anthropic/claude-sonnet-4-20250514}}"
-OPENCODE_TIMEOUT_SECONDS="${ACP_OPENCODE_TIMEOUT_SECONDS:-${F_LOSNING_OPENCODE_TIMEOUT_SECONDS:-900}}"
-KILO_MODEL="${ACP_KILO_MODEL:-${F_LOSNING_KILO_MODEL:-anthropic/claude-sonnet-4-20250514}}"
-KILO_TIMEOUT_SECONDS="${ACP_KILO_TIMEOUT_SECONDS:-${F_LOSNING_KILO_TIMEOUT_SECONDS:-900}}"
-printf -v SESSION_Q '%q' "$SESSION"
-printf -v CONFIG_YAML_Q '%q' "$CONFIG_YAML"
-printf -v ADAPTER_ID_Q '%q' "$ADAPTER_ID"
-printf -v CANONICAL_REPO_ROOT_Q '%q' "$CANONICAL_REPO_ROOT"
-RECONCILE_ENV_PREFIX="ACP_PROJECT_ID=${ADAPTER_ID_Q} AGENT_PROJECT_ID=${ADAPTER_ID_Q} AGENT_CONTROL_PLANE_CONFIG=${CONFIG_YAML_Q} ACP_CONFIG=${CONFIG_YAML_Q} ACP_ROOT=${CANONICAL_REPO_ROOT_Q} AGENT_CONTROL_PLANE_ROOT=${CANONICAL_REPO_ROOT_Q}"
-
-# The materialized skills surface is cleaned up after each heartbeat cycle.
-# Reconcile runs post-tmux via nohup, after the skills dir is gone.
-# Use the permanent runtime-home/tools/bin path derived from AGENT_PLATFORM_HOME.
-_runtime_tools_bin="${AGENT_PLATFORM_HOME:-${HOME}/.agent-runtime}/runtime-home/tools/bin"
-if [[ -f "${_runtime_tools_bin}/reconcile-pr-worker.sh" ]]; then
-  RECONCILE_ISSUE_BIN="${_runtime_tools_bin}/reconcile-issue-worker.sh"
-  RECONCILE_PR_BIN="${_runtime_tools_bin}/reconcile-pr-worker.sh"
-else
-  RECONCILE_ISSUE_BIN="${WORKSPACE_DIR}/bin/reconcile-issue-worker.sh"
-  RECONCILE_PR_BIN="${WORKSPACE_DIR}/bin/reconcile-pr-worker.sh"
-fi
-
-case "$SESSION" in
-  "${ISSUE_SESSION_PREFIX}"*)
-    TASK_KIND="issue"
-    TASK_ID="${ISSUE_ID:-${SESSION#${ISSUE_SESSION_PREFIX}}}"
-    if [[ "${RESIDENT_WORKER_ENABLED}" != "yes" ]]; then
-      RECONCILE_COMMAND="${RECONCILE_ENV_PREFIX} ${RECONCILE_ISSUE_BIN} ${SESSION_Q}"
-    fi
-    ;;
-  "${PR_SESSION_PREFIX}"*)
-    TASK_KIND="pr"
-    TASK_ID="${PR_NUMBER:-${SESSION#${PR_SESSION_PREFIX}}}"
-    RECONCILE_COMMAND="${RECONCILE_ENV_PREFIX} ${RECONCILE_PR_BIN} ${SESSION_Q}"
-    ;;
-esac
-
-realpath_safe() {
-  local path="${1:-}"
-  [[ -n "$path" ]] || return 1
-  if command -v python3 >/dev/null 2>&1; then
-    python3 - "$path" <<'PY'
-import os
-import sys
-print(os.path.realpath(sys.argv[1]))
-PY
-    return
-  fi
-  cd "$path" 2>/dev/null && pwd -P
-}
-
-assert_isolated_worker_worktree() {
-  local worktree_real worktree_root_real canonical_real retained_real git_common_dir expected_git_common_dir
-  worktree_real="$(realpath_safe "$WORKTREE")"
-  worktree_root_real="$(realpath_safe "$WORKTREE_ROOT")"
-  canonical_real="$(realpath_safe "$CANONICAL_REPO_ROOT")"
-  retained_real="$(realpath_safe "$RETAINED_REPO_ROOT")"
-  expected_git_common_dir="$(realpath_safe "${AGENT_REPO_ROOT}/.git")"
-
-  if [[ -z "$worktree_real" || ! -d "$worktree_real" ]]; then
-    echo "invalid worker worktree: $WORKTREE" >&2
-    exit 1
-  fi
-
-  if [[ -n "$canonical_real" && "$worktree_real" == "$canonical_real" ]]; then
-    echo "refusing to run worker in canonical checkout: $worktree_real" >&2
-    exit 1
-  fi
-
-  if [[ -n "$retained_real" && ( "$worktree_real" == "$retained_real" || "${worktree_real}/" == "${retained_real}/"* ) ]]; then
-    echo "refusing to run worker in retained checkout: $worktree_real" >&2
-    exit 1
-  fi
-
-  if [[ -z "$worktree_root_real" || "${worktree_real}/" != "${worktree_root_real}/"* ]]; then
-    echo "refusing to run worker outside managed worktree root: $worktree_real" >&2
-    exit 1
-  fi
-
-  git_common_dir="$(git -C "$WORKTREE" rev-parse --git-common-dir 2>/dev/null || true)"
-  if [[ -z "$git_common_dir" ]]; then
-    echo "unable to resolve git common dir for worker worktree: $worktree_real" >&2
-    exit 1
-  fi
-  if [[ "$git_common_dir" == /* ]]; then
-    git_common_dir="$(realpath_safe "$git_common_dir")"
-  else
-    git_common_dir="$(realpath_safe "$WORKTREE/$git_common_dir")"
-  fi
-  if [[ -z "$expected_git_common_dir" || "$git_common_dir" != "$expected_git_common_dir" ]]; then
-    echo "refusing to run worker with non-agent git dir: $git_common_dir" >&2
-    exit 1
-  fi
-}
-
-assert_isolated_worker_worktree
-
-ARGS=(
-  --mode "$MODE"
-  --session "$SESSION"
-  --worktree "$WORKTREE"
-  --prompt-file "$PROMPT_FILE"
-  --runs-root "$RUNS_ROOT"
-  --adapter-id "$ADAPTER_ID"
-  --task-kind "$TASK_KIND"
-  --task-id "$TASK_ID"
-  --env-prefix "F_LOSNING_"
-  --context "ISSUE_ID=${ISSUE_ID}"
-  --context "ISSUE_URL=${ISSUE_URL}"
-  --context "ISSUE_AUTOMERGE=${ISSUE_AUTOMERGE}"
-  --context "PR_NUMBER=${PR_NUMBER}"
-  --context "PR_URL=${PR_URL}"
-  --context "PR_HEAD_REF=${PR_HEAD_REF}"
-  --context "CODING_WORKER=${CODING_WORKER}"
-  --context "FLOW_TOOLS_DIR=${FLOW_TOOLS_DIR}"
-  --context "RESIDENT_WORKER_ENABLED=${RESIDENT_WORKER_ENABLED}"
-  --context "RESIDENT_WORKER_KEY=${RESIDENT_WORKER_KEY}"
-  --context "RESIDENT_WORKER_DIR=${RESIDENT_WORKER_DIR}"
-  --context "RESIDENT_WORKER_META_FILE=${RESIDENT_WORKER_META_FILE}"
-  --context "RESIDENT_TASK_COUNT=${RESIDENT_TASK_COUNT}"
-  --context "RESIDENT_WORKTREE_REUSED=${RESIDENT_WORKTREE_REUSED}"
-  --context "RESIDENT_OPENCLAW_AGENT_ID=${RESIDENT_OPENCLAW_AGENT_ID}"
-  --context "RESIDENT_OPENCLAW_SESSION_ID=${RESIDENT_OPENCLAW_SESSION_ID}"
-  --context "RESIDENT_OPENCLAW_AGENT_DIR=${RESIDENT_OPENCLAW_AGENT_DIR}"
-  --context "RESIDENT_OPENCLAW_STATE_DIR=${RESIDENT_OPENCLAW_STATE_DIR}"
-  --context "RESIDENT_OPENCLAW_CONFIG_PATH=${RESIDENT_OPENCLAW_CONFIG_PATH}"
-  --collect-file "pr-comment.md"
-  --collect-file "issue-comment.md"
-  --collect-file "verification.jsonl"
-)
-if [[ -n "$RECONCILE_COMMAND" ]]; then
-  ARGS+=(--reconcile-command "$RECONCILE_COMMAND")
-fi
-
-case "$CODING_WORKER" in
-  codex)
-    ARGS+=(
-      --safe-profile "${CODEX_PROFILE_SAFE}"
-      --bypass-profile "${CODEX_PROFILE_BYPASS}"
-    )
-    bash "${FLOW_TOOLS_DIR}/agent-project-run-codex-session" "${ARGS[@]}"
-    ;;
-  claude)
-    ARGS+=(
-      --claude-model "${CLAUDE_MODEL}"
-      --claude-permission-mode "${CLAUDE_PERMISSION_MODE}"
-      --claude-effort "${CLAUDE_EFFORT}"
-      --claude-timeout-seconds "${CLAUDE_TIMEOUT_SECONDS}"
-      --claude-max-attempts "${CLAUDE_MAX_ATTEMPTS}"
-      --claude-retry-backoff-seconds "${CLAUDE_RETRY_BACKOFF_SECONDS}"
-    )
-    bash "${FLOW_TOOLS_DIR}/agent-project-run-claude-session" "${ARGS[@]}"
-    ;;
-  openclaw)
-    ARGS+=(
-      --openclaw-model "${OPENCLAW_MODEL}"
-      --openclaw-thinking "${OPENCLAW_THINKING}"
-      --openclaw-timeout-seconds "${OPENCLAW_TIMEOUT_SECONDS}"
-    )
-    if [[ "${RESIDENT_WORKER_ENABLED}" == "yes" ]]; then
-      ARGS+=(
-        --keep-agent
-        --openclaw-agent-id "${RESIDENT_OPENCLAW_AGENT_ID}"
-        --openclaw-session-id "${RESIDENT_OPENCLAW_SESSION_ID}"
-        --openclaw-agent-dir "${RESIDENT_OPENCLAW_AGENT_DIR}"
-        --openclaw-state-dir "${RESIDENT_OPENCLAW_STATE_DIR}"
-        --openclaw-config-path "${RESIDENT_OPENCLAW_CONFIG_PATH}"
-      )
-    fi
-    bash "${FLOW_TOOLS_DIR}/agent-project-run-openclaw-session" "${ARGS[@]}"
-    ;;
-  opencode)
-    ARGS+=(
-      --opencode-model "${OPENCODE_MODEL}"
-      --opencode-timeout-seconds "${OPENCODE_TIMEOUT_SECONDS}"
-    )
-    bash "${FLOW_TOOLS_DIR}/agent-project-run-opencode-session" "${ARGS[@]}"
-    ;;
-  kilo)
-    ARGS+=(
-      --kilo-model "${KILO_MODEL}"
-      --kilo-timeout-seconds "${KILO_TIMEOUT_SECONDS}"
-    )
-    bash "${FLOW_TOOLS_DIR}/agent-project-run-kilo-session" "${ARGS[@]}"
-    ;;
-  ollama)
-    ARGS+=(
-      --ollama-model "${OLLAMA_MODEL}"
-      --ollama-base-url "${OLLAMA_BASE_URL}"
-      --ollama-timeout-seconds "${OLLAMA_TIMEOUT_SECONDS}"
-    )
-    bash "${FLOW_TOOLS_DIR}/agent-project-run-ollama-session" "${ARGS[@]}"
-    ;;
-  pi)
-    ARGS+=(
-      --pi-model "${PI_MODEL}"
-      --pi-thinking "${PI_THINKING}"
-      --pi-timeout-seconds "${PI_TIMEOUT_SECONDS}"
-      --pi-stall-seconds "${PI_STALL_SECONDS}"
-    )
-    bash "${FLOW_TOOLS_DIR}/agent-project-run-pi-session" "${ARGS[@]}"
-    ;;
-  *)
-    echo "unsupported coding worker: ${CODING_WORKER}" >&2
-    exit 1
-    ;;
-esac

package/tools/bin/serve-dashboard.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-exec python3 "${SCRIPT_DIR}/../dashboard/server.py" "$@"

package/tools/bin/split-retained-slice.sh

@@ -1,124 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SOURCE_ROOT=""
-TARGET_ROOT=""
-PATHS_FILE=""
-BACKUP_ROOT=""
-MOVE_MODE="false"
-
-usage() {
-  cat <<'EOF'
-Usage:
-  split-retained-slice.sh --source <path> --target <path> --paths-file <file> [options]
-
-Copies a curated slice of uncommitted changes from one retained worktree to
-another. Optionally removes that slice from the source after verifying the copy.
-
-Options:
-  --source <path>       Source retained worktree
-  --target <path>       Target retained worktree
-  --paths-file <file>   Newline-delimited relative paths to copy
-  --backup-root <path>  Where to store a safety backup copy (default: mktemp)
-  --move                Remove the copied paths from the source after verify
-  --help                Show this help
-EOF
-}
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --source) SOURCE_ROOT="${2:-}"; shift 2 ;;
-    --target) TARGET_ROOT="${2:-}"; shift 2 ;;
-    --paths-file) PATHS_FILE="${2:-}"; shift 2 ;;
-    --backup-root) BACKUP_ROOT="${2:-}"; shift 2 ;;
-    --move) MOVE_MODE="true"; shift ;;
-    --help|-h) usage; exit 0 ;;
-    *) echo "Unknown argument: $1" >&2; usage >&2; exit 1 ;;
-  esac
-done
-
-if [[ -z "$SOURCE_ROOT" || -z "$TARGET_ROOT" || -z "$PATHS_FILE" ]]; then
-  usage >&2
-  exit 1
-fi
-
-for required_path in "$SOURCE_ROOT" "$TARGET_ROOT" "$PATHS_FILE"; do
-  [[ -e "$required_path" ]] || { echo "missing path: $required_path" >&2; exit 1; }
-done
-
-if [[ ! -d "$SOURCE_ROOT/.git" && ! -f "$SOURCE_ROOT/.git" ]]; then
-  echo "source is not a git checkout: $SOURCE_ROOT" >&2
-  exit 1
-fi
-if [[ ! -d "$TARGET_ROOT/.git" && ! -f "$TARGET_ROOT/.git" ]]; then
-  echo "target is not a git checkout: $TARGET_ROOT" >&2
-  exit 1
-fi
-
-if [[ -n "$(git -C "$TARGET_ROOT" status --short)" ]]; then
-  echo "target worktree must be clean before splitting: $TARGET_ROOT" >&2
-  exit 1
-fi
-
-if [[ -z "$BACKUP_ROOT" ]]; then
-  BACKUP_ROOT="$(mktemp -d "${TMPDIR:-/tmp}/retained-slice-backup.XXXXXX")"
-else
-  mkdir -p "$BACKUP_ROOT"
-fi
-
-copy_path() {
-  local source_path="${1:?source path required}"
-  local dest_root="${2:?destination root required}"
-  local rel_path="${3:?relative path required}"
-
-  if [[ -d "$source_path" ]]; then
-    mkdir -p "$(dirname "${dest_root}/${rel_path}")"
-    rm -rf "${dest_root}/${rel_path}"
-    cp -R "$source_path" "${dest_root}/${rel_path}"
-  else
-    mkdir -p "$(dirname "${dest_root}/${rel_path}")"
-    cp -p "$source_path" "${dest_root}/${rel_path}"
-  fi
-}
-
-tracked_path_exists() {
-  local repo_root="${1:?repo root required}"
-  local rel_path="${2:?relative path required}"
-  git -C "$repo_root" ls-files --error-unmatch -- "$rel_path" >/dev/null 2>&1
-}
-
-while IFS= read -r rel_path || [[ -n "$rel_path" ]]; do
-  [[ -n "$rel_path" ]] || continue
-  [[ "$rel_path" != \#* ]] || continue
-
-  source_path="${SOURCE_ROOT}/${rel_path}"
-    [[ -e "$source_path" ]] || { echo "source path missing: $rel_path" >&2; exit 1; }
-
-    copy_path "$source_path" "$BACKUP_ROOT" "$rel_path"
-    copy_path "$source_path" "$TARGET_ROOT" "$rel_path"
-
-  diff -qr "$source_path" "${TARGET_ROOT}/${rel_path}" >/dev/null
-done <"$PATHS_FILE"
-
-if [[ "$MOVE_MODE" == "true" ]]; then
-  while IFS= read -r rel_path || [[ -n "$rel_path" ]]; do
-    [[ -n "$rel_path" ]] || continue
-    [[ "$rel_path" != \#* ]] || continue
-
-    was_tracked="false"
-    if tracked_path_exists "$SOURCE_ROOT" "$rel_path"; then
-      was_tracked="true"
-      git -C "$SOURCE_ROOT" restore --worktree --source=HEAD -- "$rel_path"
-    fi
-
-    if [[ "$was_tracked" != "true" && -e "${SOURCE_ROOT}/${rel_path}" ]]; then
-      rm -rf "${SOURCE_ROOT:?}/${rel_path}"
-    fi
-  done <"$PATHS_FILE"
-fi
-
-printf 'SOURCE_ROOT=%s\n' "$SOURCE_ROOT"
-printf 'TARGET_ROOT=%s\n' "$TARGET_ROOT"
-printf 'PATHS_FILE=%s\n' "$PATHS_FILE"
-printf 'BACKUP_ROOT=%s\n' "$BACKUP_ROOT"
-printf 'MOVE_MODE=%s\n' "$MOVE_MODE"