@cyperx/clawforge 1.2.0 → 1.4.0

package/VERSION

@@ -1 +1 @@
-1.2.0
+1.4.0

package/bin/clawforge

@@ -81,6 +81,15 @@ Power Features (v1.2):
   summary     AI-generated summary of what an agent did
   parse-cost  Parse real cost/token data from agent output
 
+Web Dashboard (v1.4):
+  web         Launch web dashboard (accessible from phone/browser)
+
+Developer Experience (v1.3):
+  profile     Manage reusable agent profiles (presets)
+  replay      Re-run a completed task with same parameters
+  export      Export task history as markdown/JSON report
+  completions Install shell tab completions (bash/zsh/fish)
+
 Evaluation (v0.6.2):
   eval        Run-eval logging and weekly summaries
 
@@ -236,6 +245,11 @@ doctor)     exec "${BIN_DIR}/doctor.sh" "$@" ;;
   multi-review) exec "${BIN_DIR}/multi-review.sh" "$@" ;;
   summary)    exec "${BIN_DIR}/summary.sh" "$@" ;;
   parse-cost) exec "${BIN_DIR}/parse-cost.sh" "$@" ;;
+  profile)    exec "${BIN_DIR}/profile.sh" "$@" ;;
+  replay)     exec "${BIN_DIR}/replay.sh" "$@" ;;
+  export)     exec "${BIN_DIR}/export.sh" "$@" ;;
+  completions) exec "${BIN_DIR}/completions.sh" "$@" ;;
+  web)        exec "${BIN_DIR}/web.sh" "$@" ;;
   logs)       exec "${BIN_DIR}/logs.sh" "$@" ;;
   on-complete) exec "${BIN_DIR}/on-complete.sh" "$@" ;;
 

package/bin/completions.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# completions.sh — Install shell completions for clawforge
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+COMP_DIR="${SCRIPT_DIR}/../completions"
+
+usage() {
+  cat <<EOF
+Usage: clawforge completions <shell>
+
+Install tab completions for clawforge.
+
+Shells:
+  bash       Install bash completions
+  zsh        Install zsh completions
+  fish       Install fish completions
+  --help     Show this help
+
+Examples:
+  clawforge completions bash
+  clawforge completions zsh
+  clawforge completions fish
+
+After installing, restart your shell or source the completion file.
+EOF
+}
+
+[[ $# -eq 0 ]] && { usage; exit 0; }
+
+case "$1" in
+  bash)
+    DEST="${BASH_COMPLETION_USER_DIR:-${HOME}/.local/share/bash-completion/completions}"
+    mkdir -p "$DEST"
+    cp "$COMP_DIR/clawforge.bash" "$DEST/clawforge"
+    echo "Installed bash completions to $DEST/clawforge"
+    echo "Restart your shell or run: source $DEST/clawforge"
+    ;;
+  zsh)
+    # Try homebrew zsh completions first, then user dir
+    if [[ -d "/opt/homebrew/share/zsh/site-functions" ]]; then
+      DEST="/opt/homebrew/share/zsh/site-functions"
+    elif [[ -d "${HOME}/.zsh/completions" ]]; then
+      DEST="${HOME}/.zsh/completions"
+    else
+      DEST="${HOME}/.zsh/completions"
+      mkdir -p "$DEST"
+      echo "Add to .zshrc: fpath=(~/.zsh/completions \$fpath)"
+    fi
+    cp "$COMP_DIR/_clawforge" "$DEST/_clawforge"
+    echo "Installed zsh completions to $DEST/_clawforge"
+    echo "Run: rm -f ~/.zcompdump && compinit"
+    ;;
+  fish)
+    DEST="${HOME}/.config/fish/completions"
+    mkdir -p "$DEST"
+    cp "$COMP_DIR/clawforge.fish" "$DEST/clawforge.fish"
+    echo "Installed fish completions to $DEST/clawforge.fish"
+    ;;
+  --help|-h)
+    usage
+    ;;
+  *)
+    echo "Unknown shell: $1"
+    echo "Supported: bash, zsh, fish"
+    exit 1
+    ;;
+esac

package/bin/doctor.sh

@@ -181,6 +181,69 @@ else
   check OK "Disk check skipped (df unavailable)"
 fi
 
+# 7. Lock file health
+echo ""
+echo "── Lock Files ────────────────────────────"
+LOCK_FILE="${CLAWFORGE_DIR}/registry/.lock"
+if [[ -f "$LOCK_FILE" ]]; then
+  LOCK_PID=$(cat "$LOCK_FILE" 2>/dev/null || true)
+  if [[ -n "$LOCK_PID" ]] && ! kill -0 "$LOCK_PID" 2>/dev/null; then
+    check WARN "Stale lock file (PID $LOCK_PID not running)"
+    if $FIX; then
+      rm -f "$LOCK_FILE"
+      echo "    → Fixed: removed stale lock"
+      FIXED=$((FIXED+1))
+    fi
+  else
+    check OK "Lock file clean"
+  fi
+else
+  check OK "No lock file"
+fi
+
+# 8. Config validation
+echo ""
+echo "── Configuration ─────────────────────────"
+USER_CFG="${HOME}/.clawforge/config.json"
+if [[ -f "$USER_CFG" ]]; then
+  if jq empty "$USER_CFG" 2>/dev/null; then
+    KEY_COUNT=$(jq 'keys | length' "$USER_CFG")
+    check OK "User config valid ($KEY_COUNT keys)"
+  else
+    check ERROR "User config is malformed JSON"
+    if $FIX; then
+      cp "$USER_CFG" "${USER_CFG}.bak"
+      echo '{}' > "$USER_CFG"
+      echo "    → Fixed: reset config (backup at ${USER_CFG}.bak)"
+      FIXED=$((FIXED+1))
+    fi
+  fi
+else
+  check OK "No user config (using defaults)"
+fi
+
+# 9. Profiles directory
+PROFILES_DIR="${HOME}/.clawforge/profiles"
+if [[ -d "$PROFILES_DIR" ]]; then
+  PROFILE_COUNT=$(find "$PROFILES_DIR" -maxdepth 1 -name "*.json" 2>/dev/null | wc -l | tr -d ' ')
+  check OK "$PROFILE_COUNT agent profile(s) configured"
+  # Validate each profile
+  shopt -s nullglob 2>/dev/null || true
+  for pf in "$PROFILES_DIR"/*.json; do
+    [[ -f "$pf" ]] || continue
+    if ! jq empty "$pf" 2>/dev/null; then
+      check WARN "Malformed profile: $(basename "$pf" .json)"
+      if $FIX; then
+        rm "$pf"
+        echo "    → Fixed: removed malformed profile"
+        FIXED=$((FIXED+1))
+      fi
+    fi
+  done
+else
+  check OK "No profiles directory"
+fi
+
 # Summary
 echo ""
 echo "────────────────────────────────────────"

package/bin/export.sh

@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+# export.sh — Export task history as markdown or JSON report
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "${SCRIPT_DIR}/../lib/common.sh"
+
+usage() {
+  cat <<EOF
+Usage: clawforge export [options]
+
+Export full task history as a report.
+
+Options:
+  --format <fmt>       Output format: markdown, json (default: markdown)
+  --status <status>    Filter by status (done, failed, running, all) (default: all)
+  --since <date>       Filter tasks since date (YYYY-MM-DD)
+  --save <path>        Save to file (default: stdout)
+  --help               Show this help
+
+Examples:
+  clawforge export                                # Full markdown report
+  clawforge export --format json                   # JSON dump
+  clawforge export --status done --save report.md  # Only completed tasks
+  clawforge export --since 2026-03-01             # Recent tasks only
+EOF
+}
+
+FORMAT="markdown" STATUS_FILTER="all" SINCE="" SAVE_PATH=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --format) FORMAT="$2"; shift 2 ;;
+    --status) STATUS_FILTER="$2"; shift 2 ;;
+    --since)  SINCE="$2"; shift 2 ;;
+    --save)   SAVE_PATH="$2"; shift 2 ;;
+    --help|-h) usage; exit 0 ;;
+    --*)      log_error "Unknown option: $1"; usage; exit 1 ;;
+    *)        shift ;;
+  esac
+done
+
+_ensure_registry
+
+# Gather all tasks (active + completed)
+COMPLETED_FILE="${CLAWFORGE_DIR}/registry/completed-tasks.jsonl"
+COSTS_FILE="${CLAWFORGE_DIR}/registry/costs.jsonl"
+
+ALL_TASKS="[]"
+
+# Active tasks
+ACTIVE=$(jq '.tasks' "$REGISTRY_FILE" 2>/dev/null || echo '[]')
+ALL_TASKS=$(echo "$ACTIVE" | jq '.')
+
+# Completed tasks
+if [[ -f "$COMPLETED_FILE" ]]; then
+  COMPLETED=$(jq -s '.' "$COMPLETED_FILE" 2>/dev/null || echo '[]')
+  ALL_TASKS=$(jq -s '.[0] + .[1] | unique_by(.id // .taskId)' <(echo "$ALL_TASKS") <(echo "$COMPLETED") 2>/dev/null || echo "$ALL_TASKS")
+fi
+
+# Apply filters
+if [[ "$STATUS_FILTER" != "all" ]]; then
+  ALL_TASKS=$(echo "$ALL_TASKS" | jq --arg s "$STATUS_FILTER" '[.[] | select(.status == $s)]')
+fi
+
+if [[ -n "$SINCE" ]]; then
+  SINCE_TS=$(date -j -f "%Y-%m-%d" "$SINCE" "+%s" 2>/dev/null || date -d "$SINCE" "+%s" 2>/dev/null || echo "0")
+  SINCE_MS=$((SINCE_TS * 1000))
+  ALL_TASKS=$(echo "$ALL_TASKS" | jq --argjson s "$SINCE_MS" '[.[] | select((.startedAt // .timestamp // 0) >= $s)]')
+fi
+
+TASK_COUNT=$(echo "$ALL_TASKS" | jq 'length')
+
+# Generate output
+generate_markdown() {
+  echo "# ClawForge Task Report"
+  echo "Generated: $(date)"
+  echo "Tasks: $TASK_COUNT"
+  [[ "$STATUS_FILTER" != "all" ]] && echo "Filter: status=$STATUS_FILTER"
+  [[ -n "$SINCE" ]] && echo "Since: $SINCE"
+  echo ""
+
+  # Summary stats
+  DONE_COUNT=$(echo "$ALL_TASKS" | jq '[.[] | select(.status == "done")] | length')
+  FAIL_COUNT=$(echo "$ALL_TASKS" | jq '[.[] | select(.status == "failed")] | length')
+  RUN_COUNT=$(echo "$ALL_TASKS" | jq '[.[] | select(.status == "running")] | length')
+
+  echo "## Summary"
+  echo "| Status | Count |"
+  echo "|--------|-------|"
+  echo "| ✅ Done | $DONE_COUNT |"
+  echo "| ❌ Failed | $FAIL_COUNT |"
+  echo "| 🔄 Running | $RUN_COUNT |"
+  echo "| Total | $TASK_COUNT |"
+  echo ""
+
+  # Costs
+  if [[ -f "$COSTS_FILE" ]] && [[ -s "$COSTS_FILE" ]]; then
+    TOTAL_COST=$(jq -s '[.[].totalCost // 0] | add' "$COSTS_FILE" 2>/dev/null || echo "0")
+    TOTAL_TOKENS=$(jq -s '[.[].totalTokens // 0] | add' "$COSTS_FILE" 2>/dev/null || echo "0")
+    echo "## Costs"
+    echo "- Total cost: \$${TOTAL_COST}"
+    echo "- Total tokens: ${TOTAL_TOKENS}"
+    echo ""
+  fi
+
+  # Task details
+  echo "## Tasks"
+  echo ""
+
+  echo "$ALL_TASKS" | jq -r '.[] | "### #\(.short_id // "—") — \(.description // .desc // "—")\n- **Status:** \(.status // "—")\n- **Mode:** \(.mode // "—")\n- **Agent:** \(.agent // "—")\n- **Branch:** \(.branch // "—")\n"' 2>/dev/null || true
+}
+
+if [[ "$FORMAT" == "json" ]]; then
+  OUTPUT=$(echo "$ALL_TASKS" | jq '.')
+else
+  OUTPUT=$(generate_markdown)
+fi
+
+if [[ -n "$SAVE_PATH" ]]; then
+  echo "$OUTPUT" > "$SAVE_PATH"
+  echo "Report saved to $SAVE_PATH ($TASK_COUNT tasks)"
+else
+  echo "$OUTPUT"
+fi

package/bin/on-complete.sh

@@ -117,7 +117,55 @@ if [[ -n "$WEBHOOK" ]]; then
   fi
 fi
 
-# 3. Auto-clean
+# 3. Discord/Slack webhook
+DISCORD_WEBHOOK=$(echo "$TASK_DATA" | jq -r '.discord_webhook // empty')
+if [[ -z "$DISCORD_WEBHOOK" ]]; then
+  DISCORD_WEBHOOK=$(config_get discord_webhook "")
+fi
+if [[ -n "$DISCORD_WEBHOOK" ]]; then
+  EMOJI="✅"
+  COLOR=5763719  # green
+  [[ "$STATUS" == "failed" ]] && { EMOJI="❌"; COLOR=15548997; }  # red
+  [[ "$STATUS" == "timeout" ]] && { EMOJI="⏰"; COLOR=16776960; }  # yellow
+  [[ "$STATUS" == "cancelled" ]] && { EMOJI="🚫"; COLOR=10070709; }  # grey
+
+  DISCORD_PAYLOAD=$(jq -cn \
+    --arg title "${EMOJI} ClawForge #${SHORT_ID} ${STATUS}" \
+    --arg desc "$DESC" \
+    --arg mode "$MODE" \
+    --arg status "$STATUS" \
+    --argjson color "$COLOR" \
+    '{embeds:[{title:$title,description:$desc,color:$color,fields:[{name:"Mode",value:$mode,inline:true},{name:"Status",value:$status,inline:true}]}]}')
+
+  if $DRY_RUN; then
+    echo "[dry-run] Would send Discord webhook"
+  else
+    curl -s -X POST -H "Content-Type: application/json" -d "$DISCORD_PAYLOAD" "$DISCORD_WEBHOOK" >/dev/null 2>&1 || log_warn "Discord webhook failed"
+    log_info "Sent Discord notification"
+  fi
+fi
+
+SLACK_WEBHOOK=$(echo "$TASK_DATA" | jq -r '.slack_webhook // empty')
+if [[ -z "$SLACK_WEBHOOK" ]]; then
+  SLACK_WEBHOOK=$(config_get slack_webhook "")
+fi
+if [[ -n "$SLACK_WEBHOOK" ]]; then
+  EMOJI="✅"
+  [[ "$STATUS" == "failed" ]] && EMOJI="❌"
+  [[ "$STATUS" == "timeout" ]] && EMOJI="⏰"
+  SLACK_PAYLOAD=$(jq -cn \
+    --arg text "${EMOJI} ClawForge #${SHORT_ID} ${STATUS}: ${DESC} (${MODE})" \
+    '{text:$text}')
+
+  if $DRY_RUN; then
+    echo "[dry-run] Would send Slack webhook"
+  else
+    curl -s -X POST -H "Content-Type: application/json" -d "$SLACK_PAYLOAD" "$SLACK_WEBHOOK" >/dev/null 2>&1 || log_warn "Slack webhook failed"
+    log_info "Sent Slack notification"
+  fi
+fi
+
+# 4. Auto-clean
 if [[ "$AUTO_CLEAN" == "true" ]]; then
   if $DRY_RUN; then
     echo "[dry-run] Would auto-clean task #${SHORT_ID}"
@@ -127,12 +175,12 @@ if [[ "$AUTO_CLEAN" == "true" ]]; then
   fi
 fi
 
-# 4. Mark hooks as fired
+# 5. Mark hooks as fired
 if ! $DRY_RUN; then
   registry_update "$TASK_ID" "hooks_fired" 'true' 2>/dev/null || true
 fi
 
-# 5. Log completion
+# 6. Log completion
 COMPLETION_LOG="${CLAWFORGE_DIR}/registry/completions.jsonl"
 if ! $DRY_RUN; then
   ENTRY=$(jq -cn \

package/bin/profile.sh

@@ -0,0 +1,138 @@
+#!/usr/bin/env bash
+# profile.sh — Manage reusable agent profiles
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "${SCRIPT_DIR}/../lib/common.sh"
+
+PROFILES_DIR="${HOME}/.clawforge/profiles"
+
+usage() {
+  cat <<EOF
+Usage: clawforge profile <subcommand> [args]
+
+Manage reusable agent profiles (saved parameter presets).
+
+Subcommands:
+  list                     List all profiles
+  show <name>              Show profile details
+  create <name> [options]  Create a new profile
+  delete <name>            Delete a profile
+  use <name>               Print spawn flags for a profile
+  --help                   Show this help
+
+Create options:
+  --agent <name>           Agent: claude or codex
+  --model <model>          Model to use
+  --effort <level>         Effort: high, medium, low
+  --timeout <minutes>      Timeout in minutes
+  --auto-clean             Enable auto-clean
+  --notify                 Enable notifications
+  --routing <strategy>     Routing: auto, cheap, quality
+
+Examples:
+  clawforge profile create fast --agent claude --model claude-haiku-3.5 --timeout 5
+  clawforge profile create quality --agent claude --model claude-opus-4 --effort high --notify
+  clawforge profile create cheap --agent codex --model gpt-5.2-codex --routing cheap
+  clawforge profile use fast
+  clawforge sprint --repo . --task "fix bug" $(clawforge profile use fast)
+EOF
+}
+
+[[ $# -eq 0 ]] && { usage; exit 0; }
+
+mkdir -p "$PROFILES_DIR"
+
+case "$1" in
+  list)
+    echo "── Agent Profiles ──"
+    if [[ -z "$(ls -A "$PROFILES_DIR" 2>/dev/null)" ]]; then
+      echo "(none — create with: clawforge profile create <name>)"
+      exit 0
+    fi
+    for f in "$PROFILES_DIR"/*.json; do
+      [[ -f "$f" ]] || continue
+      name=$(basename "$f" .json)
+      agent=$(jq -r '.agent // "—"' "$f")
+      model=$(jq -r '.model // "—"' "$f")
+      printf "  %-15s agent=%-8s model=%s\n" "$name" "$agent" "$model"
+    done
+    ;;
+
+  show)
+    [[ -z "${2:-}" ]] && { log_error "Profile name required"; exit 1; }
+    PROFILE_FILE="$PROFILES_DIR/$2.json"
+    [[ -f "$PROFILE_FILE" ]] || { log_error "Profile '$2' not found"; exit 1; }
+    echo "── Profile: $2 ──"
+    jq '.' "$PROFILE_FILE"
+    ;;
+
+  create)
+    shift
+    [[ -z "${1:-}" ]] && { log_error "Profile name required"; exit 1; }
+    PROFILE_NAME="$1"; shift
+
+    AGENT="" MODEL="" EFFORT="" TIMEOUT="" AUTO_CLEAN=false NOTIFY=false ROUTING=""
+    while [[ $# -gt 0 ]]; do
+      case "$1" in
+        --agent)      AGENT="$2"; shift 2 ;;
+        --model)      MODEL="$2"; shift 2 ;;
+        --effort)     EFFORT="$2"; shift 2 ;;
+        --timeout)    TIMEOUT="$2"; shift 2 ;;
+        --auto-clean) AUTO_CLEAN=true; shift ;;
+        --notify)     NOTIFY=true; shift ;;
+        --routing)    ROUTING="$2"; shift 2 ;;
+        *) log_error "Unknown option: $1"; exit 1 ;;
+      esac
+    done
+
+    PROFILE_FILE="$PROFILES_DIR/${PROFILE_NAME}.json"
+    jq -cn \
+      --arg agent "$AGENT" \
+      --arg model "$MODEL" \
+      --arg effort "$EFFORT" \
+      --arg timeout "$TIMEOUT" \
+      --argjson autoClean "$AUTO_CLEAN" \
+      --argjson notify "$NOTIFY" \
+      --arg routing "$ROUTING" \
+      '{agent:$agent,model:$model,effort:$effort,timeout:$timeout,autoClean:$autoClean,notify:$notify,routing:$routing} | with_entries(select(.value != "" and .value != null))' \
+      > "$PROFILE_FILE"
+
+    echo "Created profile '$PROFILE_NAME' at $PROFILE_FILE"
+    jq '.' "$PROFILE_FILE"
+    ;;
+
+  delete)
+    [[ -z "${2:-}" ]] && { log_error "Profile name required"; exit 1; }
+    PROFILE_FILE="$PROFILES_DIR/$2.json"
+    [[ -f "$PROFILE_FILE" ]] || { log_error "Profile '$2' not found"; exit 1; }
+    rm "$PROFILE_FILE"
+    echo "Deleted profile '$2'"
+    ;;
+
+  use)
+    [[ -z "${2:-}" ]] && { log_error "Profile name required"; exit 1; }
+    PROFILE_FILE="$PROFILES_DIR/$2.json"
+    [[ -f "$PROFILE_FILE" ]] || { log_error "Profile '$2' not found"; exit 1; }
+
+    FLAGS=""
+    agent=$(jq -r '.agent // empty' "$PROFILE_FILE")
+    model=$(jq -r '.model // empty' "$PROFILE_FILE")
+    effort=$(jq -r '.effort // empty' "$PROFILE_FILE")
+    timeout=$(jq -r '.timeout // empty' "$PROFILE_FILE")
+    auto_clean=$(jq -r '.autoClean // false' "$PROFILE_FILE")
+    notify=$(jq -r '.notify // false' "$PROFILE_FILE")
+
+    [[ -n "$agent" ]] && FLAGS+="--agent $agent "
+    [[ -n "$model" ]] && FLAGS+="--model $model "
+    [[ -n "$effort" ]] && FLAGS+="--effort $effort "
+    [[ -n "$timeout" ]] && FLAGS+="--timeout $timeout "
+    [[ "$auto_clean" == "true" ]] && FLAGS+="--auto-clean "
+    [[ "$notify" == "true" ]] && FLAGS+="--notify "
+
+    echo "$FLAGS"
+    ;;
+
+  --help|-h) usage ;;
+  *) log_error "Unknown subcommand: $1"; usage; exit 1 ;;
+esac

package/bin/replay.sh

@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+# replay.sh — Re-run a completed task with the same parameters
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "${SCRIPT_DIR}/../lib/common.sh"
+
+usage() {
+  cat <<EOF
+Usage: clawforge replay <id> [options]
+
+Re-run a completed task with the same parameters on a fresh worktree.
+
+Arguments:
+  <id>                 Task ID or short ID
+
+Options:
+  --model <model>      Override model (default: same as original)
+  --agent <agent>      Override agent (default: same as original)
+  --branch <name>      Override branch name (default: original-retry-N)
+  --dry-run            Show what would run
+  --help               Show this help
+
+Examples:
+  clawforge replay 1
+  clawforge replay 1 --model claude-opus-4
+  clawforge replay 1 --dry-run
+EOF
+}
+
+TASK_REF="" MODEL_OVERRIDE="" AGENT_OVERRIDE="" BRANCH_OVERRIDE="" DRY_RUN=false
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --model)   MODEL_OVERRIDE="$2"; shift 2 ;;
+    --agent)   AGENT_OVERRIDE="$2"; shift 2 ;;
+    --branch)  BRANCH_OVERRIDE="$2"; shift 2 ;;
+    --dry-run) DRY_RUN=true; shift ;;
+    --help|-h) usage; exit 0 ;;
+    --*)       log_error "Unknown option: $1"; usage; exit 1 ;;
+    *)         TASK_REF="$1"; shift ;;
+  esac
+done
+
+[[ -z "$TASK_REF" ]] && { log_error "Task ID required"; usage; exit 1; }
+
+_ensure_registry
+
+# Resolve task (check completed tasks too)
+TASK_DATA=""
+if [[ "$TASK_REF" =~ ^[0-9]+$ ]]; then
+  TASK_DATA=$(jq -r --argjson sid "$TASK_REF" '.tasks[] | select(.short_id == $sid)' "$REGISTRY_FILE" 2>/dev/null || true)
+fi
+if [[ -z "$TASK_DATA" ]]; then
+  TASK_DATA=$(registry_get "$TASK_REF" 2>/dev/null || true)
+fi
+# Also check completed-tasks.jsonl
+if [[ -z "$TASK_DATA" ]]; then
+  COMPLETED_FILE="${CLAWFORGE_DIR}/registry/completed-tasks.jsonl"
+  if [[ -f "$COMPLETED_FILE" ]]; then
+    if [[ "$TASK_REF" =~ ^[0-9]+$ ]]; then
+      TASK_DATA=$(jq -r --argjson sid "$TASK_REF" 'select(.short_id == $sid)' "$COMPLETED_FILE" 2>/dev/null | tail -1 || true)
+    else
+      TASK_DATA=$(jq -r --arg id "$TASK_REF" 'select(.id == $id)' "$COMPLETED_FILE" 2>/dev/null | tail -1 || true)
+    fi
+  fi
+fi
+
+if [[ -z "$TASK_DATA" ]]; then
+  log_error "Task '$TASK_REF' not found in active or completed tasks"
+  exit 1
+fi
+
+# Extract original parameters
+ORIG_REPO=$(echo "$TASK_DATA" | jq -r '.repo // empty')
+ORIG_BRANCH=$(echo "$TASK_DATA" | jq -r '.branch // empty')
+ORIG_TASK=$(echo "$TASK_DATA" | jq -r '.description // empty')
+ORIG_AGENT=$(echo "$TASK_DATA" | jq -r '.agent // "claude"')
+ORIG_MODEL=$(echo "$TASK_DATA" | jq -r '.model // empty')
+ORIG_MODE=$(echo "$TASK_DATA" | jq -r '.mode // "sprint"')
+ORIG_EFFORT=$(echo "$TASK_DATA" | jq -r '.effort // "high"')
+SHORT_ID=$(echo "$TASK_DATA" | jq -r '.short_id // 0')
+
+# Apply overrides
+AGENT="${AGENT_OVERRIDE:-$ORIG_AGENT}"
+MODEL="${MODEL_OVERRIDE:-$ORIG_MODEL}"
+
+# Generate retry branch name
+if [[ -n "$BRANCH_OVERRIDE" ]]; then
+  NEW_BRANCH="$BRANCH_OVERRIDE"
+else
+  # Find retry number
+  RETRY=1
+  while true; do
+    NEW_BRANCH="${ORIG_BRANCH}-retry-${RETRY}"
+    # Check if branch exists
+    if [[ -n "$ORIG_REPO" ]] && git -C "$ORIG_REPO" rev-parse --verify "$NEW_BRANCH" >/dev/null 2>&1; then
+      RETRY=$((RETRY + 1))
+    else
+      break
+    fi
+  done
+fi
+
+[[ -z "$ORIG_REPO" ]] && { log_error "Original task has no repo path — can't replay"; exit 1; }
+[[ -z "$ORIG_TASK" ]] && { log_error "Original task has no description — can't replay"; exit 1; }
+
+# Show replay plan
+echo "🔄 Replaying task #${SHORT_ID}"
+echo "  Description: $ORIG_TASK"
+echo "  Mode:        $ORIG_MODE"
+echo "  Agent:       $AGENT"
+echo "  Model:       $MODEL"
+echo "  Branch:      $NEW_BRANCH"
+echo "  Repo:        $ORIG_REPO"
+echo ""
+
+if $DRY_RUN; then
+  echo "[dry-run] Would run:"
+  echo "  clawforge ${ORIG_MODE} --repo $ORIG_REPO --task \"$ORIG_TASK\" --agent $AGENT --model $MODEL"
+  exit 0
+fi
+
+# Dispatch based on mode
+SPAWN_CMD=(
+  "${SCRIPT_DIR}/spawn-agent.sh"
+  --repo "$ORIG_REPO"
+  --branch "$NEW_BRANCH"
+  --task "$ORIG_TASK"
+  --agent "$AGENT"
+)
+[[ -n "$MODEL" ]] && SPAWN_CMD+=(--model "$MODEL")
+
+exec "${SPAWN_CMD[@]}"

package/bin/spawn-agent.sh

@@ -17,13 +17,14 @@ Options:
   --agent <name>       Agent to use: claude or codex (default: auto-detect)
   --model <model>      Model override
   --effort <level>     Effort level: high, medium, low (default: high)
+  --after <id>         Wait for task <id> to complete before spawning
   --dry-run            Do everything except launch the agent
   --help               Show this help
 EOF
 }
 
 # ── Parse args ─────────────────────────────────────────────────────────
-REPO="" BRANCH="" TASK="" AGENT="" MODEL="" EFFORT="" DRY_RUN=false
+REPO="" BRANCH="" TASK="" AGENT="" MODEL="" EFFORT="" DRY_RUN=false AFTER=""
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
@@ -33,6 +34,7 @@ while [[ $# -gt 0 ]]; do
     --agent)    AGENT="$2"; shift 2 ;;
     --model)    MODEL="$2"; shift 2 ;;
     --effort)   EFFORT="$2"; shift 2 ;;
+    --after)    AFTER="$2"; shift 2 ;;
     --dry-run)  DRY_RUN=true; shift ;;
     --help|-h)  usage; exit 0 ;;
     *)          log_error "Unknown option: $1"; usage; exit 1 ;;
@@ -45,6 +47,40 @@ done
 [[ -z "$TASK" ]]   && { log_error "--task is required"; usage; exit 1; }
 [[ -d "$REPO/.git" ]] || [[ -f "$REPO/.git" ]] || { log_error "Not a git repo: $REPO"; exit 1; }
 
+# ── Wait for dependency ──────────────────────────────────────────────
+if [[ -n "$AFTER" ]]; then
+  log_info "Waiting for task $AFTER to complete before spawning..."
+  WAIT_TIMEOUT=${CLAWFORGE_DEP_TIMEOUT:-3600}  # 1 hour default
+  ELAPSED=0
+  INTERVAL=5
+  while [[ $ELAPSED -lt $WAIT_TIMEOUT ]]; do
+    DEP_STATUS=""
+    if [[ "$AFTER" =~ ^[0-9]+$ ]]; then
+      DEP_STATUS=$(jq -r --argjson sid "$AFTER" '.tasks[] | select(.short_id == $sid) | .status' "$REGISTRY_FILE" 2>/dev/null || true)
+    else
+      DEP_STATUS=$(jq -r --arg id "$AFTER" '.tasks[] | select(.id == $id) | .status' "$REGISTRY_FILE" 2>/dev/null || true)
+    fi
+    case "$DEP_STATUS" in
+      done)
+        log_info "Dependency $AFTER completed. Spawning..."
+        break
+        ;;
+      failed|timeout|cancelled)
+        log_error "Dependency $AFTER ended with status: $DEP_STATUS. Aborting spawn."
+        exit 1
+        ;;
+      *)
+        sleep $INTERVAL
+        ELAPSED=$((ELAPSED + INTERVAL))
+        ;;
+    esac
+  done
+  if [[ $ELAPSED -ge $WAIT_TIMEOUT ]]; then
+    log_error "Dependency wait timed out after ${WAIT_TIMEOUT}s"
+    exit 1
+  fi
+fi
+
 # ── Resolve settings ──────────────────────────────────────────────────
 RESOLVED_AGENT=$(detect_agent "${AGENT:-}")
 EFFORT="${EFFORT:-$(config_get default_effort high)}"

package/bin/web.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# web.sh — Launch the ClawForge web dashboard
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+CLAWFORGE_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+WEB_DIR="${CLAWFORGE_DIR}/web"
+BINARY="${SCRIPT_DIR}/clawforge-web"
+
+export CLAWFORGE_DIR
+
+usage() {
+  cat <<EOF
+Usage: clawforge web [options]
+
+Launch the ClawForge web dashboard.
+Accessible from your phone, tablet, or any browser on the network.
+
+Options:
+  --port <port>        Port to listen on (default: 9876)
+  --open               Open in default browser
+  --build              Force rebuild the web binary
+  --help               Show this help
+
+Examples:
+  clawforge web                    # Start on http://localhost:9876
+  clawforge web --port 8080        # Custom port
+  clawforge web --open             # Start + open browser
+
+Keyboard shortcuts (in browser):
+  1/2/3/4      Filter: all/running/done/failed
+  Escape       Close preview panel
+  Click task   Open detail + agent output preview
+EOF
+}
+
+PORT=9876
+OPEN=false
+BUILD=false
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --port|-p)   PORT="$2"; shift 2 ;;
+    --open|-o)   OPEN=true; shift ;;
+    --build)     BUILD=true; shift ;;
+    --help|-h)   usage; exit 0 ;;
+    *)           shift ;;
+  esac
+done
+
+# Build if needed
+if [[ ! -f "$BINARY" ]] || $BUILD; then
+  echo "Building web dashboard..."
+  if ! command -v go &>/dev/null; then
+    echo "Error: go is required. Install with: brew install go"
+    exit 1
+  fi
+  (cd "$WEB_DIR" && go build -o "$BINARY" .)
+  echo "Built: $BINARY"
+fi
+
+# Open browser
+if $OPEN; then
+  (sleep 1 && open "http://localhost:${PORT}" 2>/dev/null || xdg-open "http://localhost:${PORT}" 2>/dev/null) &
+fi
+
+# Run
+exec "$BINARY" --port="$PORT"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyperx/clawforge",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Multi-mode coding workflow CLI for orchestrating AI coding agents",
   "bin": {
     "@cyperx/clawforge": "./bin/clawforge"
@@ -12,13 +12,23 @@
     "type": "git",
     "url": "https://github.com/cyperx84/clawforge.git"
   },
-  "keywords": ["cli", "coding", "agents", "orchestration", "tmux", "worktree"],
+  "keywords": [
+    "cli",
+    "coding",
+    "agents",
+    "orchestration",
+    "tmux",
+    "worktree"
+  ],
   "author": "cyperx84",
   "license": "MIT",
   "engines": {
     "node": ">=18"
   },
-  "os": ["darwin", "linux"],
+  "os": [
+    "darwin",
+    "linux"
+  ],
   "files": [
     "bin/",
     "lib/",