deepflow 0.1.63 → 0.1.65

package/bin/deepflow-auto.sh

@@ -168,32 +168,28 @@ discover_specs() {
 # Context-monitored claude -p wrapper
 # ---------------------------------------------------------------------------
 
-# run_claude_monitored <working_dir> <prompt_text> [session_id]
+# run_claude_monitored <working_dir> <prompt_text>
 #
 # Runs `claude -p --output-format stream-json` and monitors token usage in
 # real time. If usage reaches CONTEXT_THRESHOLD_PCT% of the context window the
-# process is killed and automatically restarted with `--resume <session_id>` so
-# it gets a fresh context window.
+# process is killed and restarted with a fresh context (same prompt, clean
+# session). Prior work persists in the worktree via committed files.
 #
 # The final result text is written to stdout. A side-effect context.json is
 # written to <working_dir>/.deepflow/context.json for statusline consumption.
 run_claude_monitored() {
   local working_dir="$1"
   local prompt_text="$2"
-  local session_id="${3:-}"
 
   local result_tmp
   result_tmp="$(mktemp)"
   local error_log
   error_log="$(mktemp)"
 
-  # Outer loop: may restart with --resume when threshold is hit
+  # Outer loop: restart with fresh context when threshold is hit
   while true; do
     # Build command arguments
     local -a cmd_args=(claude -p --output-format stream-json --dangerously-skip-permissions)
-    if [[ -n "$session_id" ]]; then
-      cmd_args+=(--resume --session-id "$session_id")
-    fi
 
     # Accumulated token count and context window size across events
     local total_tokens=0
@@ -207,13 +203,8 @@ run_claude_monitored() {
     fifo_path="$(mktemp -u)"
     mkfifo "$fifo_path"
 
-    if [[ -n "$session_id" ]]; then
-      "${cmd_args[@]}" < /dev/null > "$fifo_path" 2>>"$error_log" &
-      claude_pid=$!
-    else
-      echo "$prompt_text" | "${cmd_args[@]}" > "$fifo_path" 2>>"$error_log" &
-      claude_pid=$!
-    fi
+    echo "$prompt_text" | "${cmd_args[@]}" > "$fifo_path" 2>>"$error_log" &
+    claude_pid=$!
 
     # Read the FIFO line-by-line (set +e to tolerate EINTR from signals)
     local capturing_result=false
@@ -304,12 +295,10 @@ run_claude_monitored() {
       : > "$error_log"
     fi
 
-    if [[ "$threshold_hit" == "true" && -n "$current_session_id" ]]; then
-      # Restart with --resume and the captured session_id
-      session_id="$current_session_id"
-      total_tokens=0
-      context_window=0
-      auto_log "Restarting claude -p with --resume session_id=${session_id}"
+    if [[ "$threshold_hit" == "true" ]]; then
+      # Restart with fresh context — the prompt is re-sent but prior work
+      # persists in the worktree (committed files, etc.)
+      auto_log "Restarting claude -p with fresh context (prior work is in worktree)"
       continue
     fi
 
@@ -608,9 +597,29 @@ run_spikes() {
     pids+=($!)
   done
 
-  # Wait for all remaining spikes to complete
+  # Wait for all remaining spikes with progress heartbeat
   auto_log "Waiting for all ${#pids[@]} spike(s) to complete..."
-  wait
+  local wait_start=$SECONDS
+  while true; do
+    local -a still_running=()
+    local pid
+    for pid in "${pids[@]}"; do
+      if kill -0 "$pid" 2>/dev/null; then
+        still_running+=("$pid")
+      fi
+    done
+    if [[ ${#still_running[@]} -eq 0 ]]; then
+      break
+    fi
+    local elapsed=$(( SECONDS - wait_start ))
+    local mins=$(( elapsed / 60 ))
+    local secs=$(( elapsed % 60 ))
+    printf "\r  ⏳ %d spike(s) running... [%dm%02ds]  " "${#still_running[@]}" "$mins" "$secs"
+    pids=("${still_running[@]}")
+    sleep 5
+  done
+  printf "\r                                        \r"
+  wait 2>/dev/null || true
   auto_log "All spikes completed for ${spec_name} cycle ${cycle}"
 
   # Collect results and process
@@ -788,9 +797,29 @@ Important:
     impl_slugs+=("$slug")
   done
 
-  # Wait for all implementations to complete
+  # Wait for all implementations with progress heartbeat
   auto_log "Waiting for all ${#pids[@]} implementation(s) to complete..."
-  wait
+  local wait_start=$SECONDS
+  while true; do
+    local -a still_running=()
+    local pid
+    for pid in "${pids[@]}"; do
+      if kill -0 "$pid" 2>/dev/null; then
+        still_running+=("$pid")
+      fi
+    done
+    if [[ ${#still_running[@]} -eq 0 ]]; then
+      break
+    fi
+    local elapsed=$(( SECONDS - wait_start ))
+    local mins=$(( elapsed / 60 ))
+    local secs=$(( elapsed % 60 ))
+    printf "\r  ⏳ %d implementation(s) running... [%dm%02ds]  " "${#still_running[@]}" "$mins" "$secs"
+    pids=("${still_running[@]}")
+    sleep 5
+  done
+  printf "\r                                              \r"
+  wait 2>/dev/null || true
   auto_log "All implementations completed for ${spec_name} cycle ${cycle}"
 
   # Collect results

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepflow",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "description": "Stay in flow state - lightweight spec-driven task orchestration for Claude Code",
   "keywords": [
     "claude",