feat: 0.2.0

.github/workflows/release.yml

@@ -92,10 +92,24 @@ jobs:
         working-directory: dist
         run: echo -n "${{ github.sha }}" > COMMIT
 
+      - name: Extract changelog section for this tag
+        run: |
+          VERSION="${GITHUB_REF_NAME#v}"
+          awk -v ver="## [$VERSION]" '
+            $0 == ver { found=1; next }
+            found && /^## \[/ { exit }
+            found { print }
+          ' CHANGELOG.md > release-notes.md
+
+          if [ ! -s release-notes.md ]; then
+            echo "No CHANGELOG.md section found for $VERSION" >&2
+            exit 1
+          fi
+
       - uses: softprops/action-gh-release@v3
         with:
+          body_path: release-notes.md
           files: |
             dist/herdr-devserver-status-*.tar.gz
             dist/SHA256SUMS
             dist/COMMIT
-          generate_release_notes: true

.gitignore

@@ -3,4 +3,5 @@
 *.log
 .env
 .vscode/
-!.vscode/extensions.json
+!.vscode/extensions.json
+.seed-state.json

CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## [0.2.0]
+
+### Fixed
+
+- `has_errors` stuck `true` after recovery once the error needle scrolled out of the read window — recompute every `Running` tick instead of gating on needle presence.
+- `status` regressed `Running` → `Starting` once the `Ready` needle/URL scrolled out of the read window — `Running` now sticky, cleared only on process restart.
+
+### Changed
+
+- `ToolDetector::match_output` — added `previous_status: ToolStatus` param.
+- `signal_matching::derive_status` — added `previous_status: ToolStatus` param.
+
+## [0.1.0]
+
+### Added
+- initial release: framework spec loader, vite detector, daemon discovery/worker loop

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "herdr-devserver-status"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 rust-version = "1.97"
 license = "MIT"

frameworks/vite.yml

@@ -32,6 +32,9 @@ signals:
   - kind: ready
     needle: "built in"
     counts_as_recent_success: true
+  - kind: ready
+    needle: "(client) hmr update"
+    counts_as_recent_success: true
   - kind: building
     needle: "build started..."
   - kind: error

herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "herdr-devserver-status"
 name = "herdr-devserver-status"
-version = "0.1.0"
+version = "0.2.0"
 min_herdr_version = "0.7.0"
 description = "Detects selected dev servers running inside Herdr panes and reports their lifecycle status."
 license = "MIT"

src/daemon/worker.rs

@@ -109,7 +109,7 @@ fn tick(
     state: &mut TrackedState,
 ) -> Result<(), crate::herdr::HerdrError> {
     let output = client::read_pane_output(pane_id, READ_LINES)?;
-    let result = detector.match_output(&output, state.has_errors);
+    let result = detector.match_output(&output, state.status, state.has_errors);
 
     let changed = result.status != state.status
         || result.has_errors != state.has_errors

src/herdr/wire.rs

@@ -84,6 +84,14 @@ pub fn extract_foreground_processes(parsed: &Value) -> Vec<ProcessInfo> {
 /// from that stderr JSON is UNVERIFIED — empirically verify against a pane
 /// that closes mid-wait before shipping.
 pub fn stderr_indicates_timeout(stderr_json: &Value) -> bool {
+    if stderr_json
+        .pointer("/error/code")
+        .and_then(Value::as_str)
+        .map(|c| c.eq_ignore_ascii_case("timeout"))
+        .unwrap_or(false)
+    {
+        return true;
+    }
     const TIMEOUT_HINT_KEYS: [&str; 2] = ["timeout", "timed_out"];
     for key in TIMEOUT_HINT_KEYS {
         if let Some(v) = stderr_json.get(key)
@@ -98,3 +106,11 @@ pub fn stderr_indicates_timeout(stderr_json: &Value) -> bool {
         .map(|r| r.eq_ignore_ascii_case("timeout"))
         .unwrap_or(false)
 }
+
+#[test]
+fn recognizes_nested_error_code_timeout() {
+    let json: Value = serde_json::from_str(
+        r#"{"error":{"code":"timeout","message":"timed out waiting for output match"},"id":"cli:pane:wait-output"}"#
+    ).unwrap();
+    assert!(stderr_indicates_timeout(&json));
+}

src/tools/framework/mod.rs

@@ -110,15 +110,16 @@ impl ToolDetector for FrameworkDetector {
         &self.signal_re
     }
 
-    fn match_output(&self, output: &str, previous_had_errors: bool) -> ToolMatchResult {
+    fn match_output(
+        &self,
+        output: &str,
+        previous_status: ToolStatus,
+        previous_had_errors: bool,
+    ) -> ToolMatchResult {
         let result =
             signal_matching::match_output(&self.spec.signals, self.url_re.as_ref(), output);
-        let derived = signal_matching::derive_status(previous_had_errors, &result);
-
-        let has_errors = if derived.status == ToolStatus::Running
-            && result.signals.contains(&SignalKind::Ready)
-            && result.signals.contains(&SignalKind::Error)
-        {
+        let derived = signal_matching::derive_status(previous_status, previous_had_errors, &result);
+        let has_errors = if derived.status == ToolStatus::Running {
             signal_matching::has_recent_error(&self.spec.signals, output)
         } else {
             derived.has_errors

src/tools/mod.rs

@@ -62,7 +62,12 @@ pub trait ToolDetector: Send + Sync {
     fn confirm(&self, procs: &[ProcessInfo]) -> Option<ProcessMatch>;
 
     fn signal_regex(&self) -> &Regex;
-    fn match_output(&self, output: &str, previous_had_errors: bool) -> ToolMatchResult;
+    fn match_output(
+        &self,
+        output: &str,
+        previous_status: ToolStatus,
+        previous_had_errors: bool,
+    ) -> ToolMatchResult;
 }
 
 /// All detectors tried, in order, against each newly seen pane's process

src/tools/signal_matching.rs

@@ -90,16 +90,20 @@ pub struct DerivedStatus {
     pub has_errors: bool,
 }
 
-pub fn derive_status(previous_had_errors: bool, result: &MatchResult) -> DerivedStatus {
-    let is_running = result.signals.contains(&SignalKind::Ready) || result.url.is_some();
+pub fn derive_status(
+    previous_status: ToolStatus,
+    previous_had_errors: bool,
+    result: &MatchResult,
+) -> DerivedStatus {
+    let is_running = previous_status == ToolStatus::Running
+        || result.signals.contains(&SignalKind::Ready)
+        || result.url.is_some();
     let saw_error = result.signals.contains(&SignalKind::Error);
 
     if is_running {
-        // Caller overrides with has_recent_error when both ready and error
-        // are present in the same read.
         DerivedStatus {
             status: ToolStatus::Running,
-            has_errors: false,
+            has_errors: previous_had_errors,
         }
     } else {
         DerivedStatus {