workstreams-cli 0.5.1__tar.gz → 0.6.1__tar.gz

{workstreams_cli-0.5.1 → workstreams_cli-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workstreams-cli
-Version: 0.5.1
+Version: 0.6.1
 Summary: Visually dispatch coding-agent work to subagents in real terminal windows and monitor it in one dashboard - for any coding agent (Claude Code, Codex, OpenCode, Qwen Code, Hermes, Cline, and more).
 Author: Dream-Pixels-Forge
 License: MIT
@@ -45,6 +45,14 @@ Key capabilities:
 - **Cross-terminal notifications** — desktop notifications (Linux `notify-send`, macOS `osascript`) plus a shared `notifications.jsonl` that other terminals can poll
 - **Agent-agnostic** — no vendor lock-in. `dispatch` and `work` send arbitrary shell commands to panes, so it works with whatever agent binary you can run from a shell
 
+## ⭐ If workstreams helps you ship faster, star the repo
+
+If you found this useful, a GitHub star helps other developers discover it.
+
+[![Star on GitHub](https://img.shields.io/github/stars/Dream-Pixels-Forge/workstreams-cli?style=social)](https://github.com/Dream-Pixels-Forge/workstreams-cli)
+
+⭐ **Star this repo:** [github.com/Dream-Pixels-Forge/workstreams-cli](https://github.com/Dream-Pixels-Forge/workstreams-cli)
+
 ## Why this exists
 
 Coding agents increasingly support "subagents" that run in the background of the main agent's process. That means: no visibility (you can't watch them), no isolation (they share one working tree and one set of installed dependencies), no way to run several in parallel on independent branches, and no shared event stream you can watch from your main terminal.
@@ -61,6 +69,7 @@ Coding agents increasingly support "subagents" that run in the background of the
 - [Configuration (.workstreams.yaml)](#configuration-workstreamsyaml)
 - [How the Multiplexers Work](#how-the-multiplexers-work)
 - [Subagent Event System (Python API + CLI)](#subagent-event-system)
+- [Confidence Scoring](#confidence-scoring)
 - [Environment Variables](#environment-variables)
 - [Exit Codes](#exit-codes)
 - [Data Locations](#data-locations)
@@ -105,7 +114,7 @@ pip install -e ".[yaml,dev]"   # dev extras add pytest
 Verify:
 
 ```bash
-workstreams --version   # -> workstreams 0.5.1
+workstreams --version   # -> workstreams 0.6.1
 ```
 
 > **Note:** every command also accepts `--json` to emit machine-readable output (where supported), which coding agents can parse. All read-side commands work without a multiplexer installed; only `start`/`dispatch`/`work`/`attach` need one.
@@ -436,6 +445,67 @@ Events are appended to `~/.workstreams/<project>/events.jsonl` using `O_APPEND`
 
 ---
 
+## Confidence Scoring
+
+Subagents are sometimes wrong. Confidence scoring lets each subagent **self-rate the quality of its result on a 0–10 scale** so the main agent (or a CI gate) can decide whether to accept, re-dispatch, or escalate. It is the difference between "subagent said it's done" and "subagent is 9/10 sure it actually delivered the right result".
+
+- The score rides in the event's `data.confidence` field — no new storage required.
+- A **gate** (`workstreams confidence --min-score N`) exits `0` when the latest score is at/above the threshold and `1` otherwise, so it drops straight into CI or a `--wait` loop.
+- Scores are clamped to `[0, 10]`; a misbehaving subagent can't emit `100`.
+
+### Emitting a score
+
+```bash
+# a subagent reports it finished, 9/10 confident
+workstreams event completed --project myproj --workstream 1 \
+    --subagent claude-code --issue 42 \
+    --message "All tests green, edge cases covered" \
+    --confidence 9
+
+# or via --data JSON
+workstreams event completed --project myproj --workstream 1 \
+    --subagent codex --issue 42 --message "Done" --data '{"confidence": 7}'
+
+# Python API (in a subagent script)
+from workstreams import subagent_report
+subagent_report("myproj", 1, "claude-code", 42, "completed", "Done",
+                data={"confidence": 9})
+```
+
+### Reading / gating on scores
+
+```bash
+# human-readable summary + gate (exit 0 if latest >= 8)
+workstreams confidence --project myproj --workstream 1 --issue 42 --min-score 8
+
+# machine-readable
+workstreams confidence --project myproj --workstream 1 --json
+
+# list every confidence-bearing event, oldest first
+workstreams confidence --project myproj --workstream 1 --records
+```
+
+Example output:
+
+```
+Confidence for ws1 #42: PASS
+  latest: 9.0/10 (completed from claude-code)
+  average: 7.0/10 over 2 report(s)
+  threshold: 8.0/10 -> All tests green, edge cases covered
+```
+
+### Using it as a CI / re-dispatch gate
+
+```bash
+# block the merge until the subagent's latest self-rating clears the bar
+workstreams confidence --project myproj --workstream 1 --issue 42 --min-score 9 \
+  || { echo "confidence too low, re-dispatching"; workstreams dispatch ...; }
+```
+
+> Scores are self-reported. Treat them as a *signal*, not a proof — pair them with real test coverage. A 10/10 that shipped a broken build is still a broken build.
+
+---
+
 ## Environment Variables
 
 All are overridable in the config file / CLI; env vars are a fallback when neither is set.
@@ -591,57 +661,21 @@ workstreams logs --workstream 1 --lines 50
 
 ## Architecture
 
-`workstreams` is a thin orchestration layer that sits between you, your git repo, a terminal multiplexer, and any coding agent binary. The core parts and how they fit together:
+`workstreams` is a thin orchestration layer that sits between you, your git repo, a terminal multiplexer, and any coding agent binary.
 
-```
-                 you / your main terminal / a CI job / a cron
-                                   │  CLI (argparse)
-                                   ▼
-        ┌─────────────────────────────────────────────────────────┐
-        │                  cli.py  (entry: workstreams)          │
-        └─────────────────────────────────────────────────────────┘
-        │  command routing          │  config resolution (flag > yaml > env > default)
-        ▼                            ▼
-┌──────────────────────┐   ┌──────────────────────┐
-│  WorkstreamsManager  │   │  config.py            │
-│  (manager.py)        │◄──│  .workstreams.yaml /  │
-│  init·start·dispatch │   │  .json load+save,     │
-│  work·sync·pr·merge· │   │  no-pyyaml fallback   │
-│  run·logs·events     │   └──────────────────────┘
-└──────┬───────────────┘
-       │
-   ┌───┴──────────────────────────────────────────────┐
-   │                                                    │
-   ▼                                                    ▼
-┌────────────────────────────┐          ┌────────────────────────────┐
-│  multiplexer/  (backends)  │          │  event_log.py  +           │
-│  tmux.py / zellij.py       │          │  subagent_client.py        │
-│  MultiplexerBase:          │          │  (Python API emitters)     │
-│   create_session, send_    │          │                            │
-│   command, list_sessions…  │          │  NOTIFIER                  │
-└─────────────┬──────────────┘          │  (notifier.py): desktop    │
-              │ send-keys / tabs        │  notify-send/osascript +   │
-              ▼                         │  notifications.jsonl       │
-      visible terminal panes ◄──────────┤                            │
-      (one per workstream lane)        └────────────────────────────┘
-              │ each pane runs its own agent (claude, codex, …)
-              │ agent appends JSONL events back
-              ▼
-┌──────────────────────────────────────────────────────────────┐
-│  ~/.workstreams/<project>/                                   │
-│    events.jsonl     shared, concurrent-safe event stream     │
-│    notifications.jsonl   cross-terminal notification queue  │
-└──────────────────────────────────────────────────────────────┘
-              ▲
-              │ re-render every 2s (configurable)
-┌────────────────────────────┐
-│  dashboard.py             │
-│  LiveDashboard: ANSI TUI  │  ◄── the only read-side that polls events live
-└────────────────────────────┘
-
-models.py defines the dataclasses (WorkstreamConfig, WorkstreamsConfig,
-WorkstreamStatus, SubagentEvent) shared across all of the above.
-```
+![workstreams architecture](https://github.com/Dream-Pixels-Forge/workstreams-cli/raw/main/assets/workstreams-architecture.webp)
+
+The diagram above shows the full data flow: the CLI routes each command to `WorkstreamsManager`, which talks to a pluggable multiplexer backend to place agents into visible terminal panes, while every lane's subagent writes JSONL events back to a shared, concurrent-safe log that the live dashboard re-renders on a timer. The core modules:
+
+- **`cli.py`** — argparse entry point; every command accepts `--project` and `--json`
+- **`manager.py`** — `WorkstreamsManager` orchestrates init/start/dispatch/work/sync/pr/merge/run/logs/events
+- **`config.py`** — loads/saves `.workstreams.yaml` (or JSON) with no-pyyaml fallback; resolution order: CLI flag > yaml > env > default
+- **`multiplexer/`** — pluggable backends behind `MultiplexerBase` (`tmux.py`, `zellij.py`, plus tmux-compatible wrappers for `nami`/`lmux`/`wmux`/`herdr`)
+- **`event_log.py` + `subagent_client.py`** — shared cross-process JSONL event stream and the Python API emitters
+- **`notifier.py`** — desktop notifications (`notify-send`/`osascript`/PowerShell) plus a `notifications.jsonl` queue
+- **`confidence.py`** — aggregates subagent self-rated 0–10 quality scores for accept / re-dispatch gating
+- **`dashboard.py`** — the live ANSI TUI that polls events and re-renders every 2s
+- **`models.py`** — dataclasses (`WorkstreamConfig`, `WorkstreamsConfig`, `WorkstreamStatus`, `SubagentEvent`) shared across all of the above
 
 How a run flows end-to-end:
 

{workstreams_cli-0.5.1 → workstreams_cli-0.6.1}/README.md

@@ -15,6 +15,14 @@ Key capabilities:
 - **Cross-terminal notifications** — desktop notifications (Linux `notify-send`, macOS `osascript`) plus a shared `notifications.jsonl` that other terminals can poll
 - **Agent-agnostic** — no vendor lock-in. `dispatch` and `work` send arbitrary shell commands to panes, so it works with whatever agent binary you can run from a shell
 
+## ⭐ If workstreams helps you ship faster, star the repo
+
+If you found this useful, a GitHub star helps other developers discover it.
+
+[![Star on GitHub](https://img.shields.io/github/stars/Dream-Pixels-Forge/workstreams-cli?style=social)](https://github.com/Dream-Pixels-Forge/workstreams-cli)
+
+⭐ **Star this repo:** [github.com/Dream-Pixels-Forge/workstreams-cli](https://github.com/Dream-Pixels-Forge/workstreams-cli)
+
 ## Why this exists
 
 Coding agents increasingly support "subagents" that run in the background of the main agent's process. That means: no visibility (you can't watch them), no isolation (they share one working tree and one set of installed dependencies), no way to run several in parallel on independent branches, and no shared event stream you can watch from your main terminal.
@@ -31,6 +39,7 @@ Coding agents increasingly support "subagents" that run in the background of the
 - [Configuration (.workstreams.yaml)](#configuration-workstreamsyaml)
 - [How the Multiplexers Work](#how-the-multiplexers-work)
 - [Subagent Event System (Python API + CLI)](#subagent-event-system)
+- [Confidence Scoring](#confidence-scoring)
 - [Environment Variables](#environment-variables)
 - [Exit Codes](#exit-codes)
 - [Data Locations](#data-locations)
@@ -75,7 +84,7 @@ pip install -e ".[yaml,dev]"   # dev extras add pytest
 Verify:
 
 ```bash
-workstreams --version   # -> workstreams 0.5.1
+workstreams --version   # -> workstreams 0.6.1
 ```
 
 > **Note:** every command also accepts `--json` to emit machine-readable output (where supported), which coding agents can parse. All read-side commands work without a multiplexer installed; only `start`/`dispatch`/`work`/`attach` need one.
@@ -406,6 +415,67 @@ Events are appended to `~/.workstreams/<project>/events.jsonl` using `O_APPEND`
 
 ---
 
+## Confidence Scoring
+
+Subagents are sometimes wrong. Confidence scoring lets each subagent **self-rate the quality of its result on a 0–10 scale** so the main agent (or a CI gate) can decide whether to accept, re-dispatch, or escalate. It is the difference between "subagent said it's done" and "subagent is 9/10 sure it actually delivered the right result".
+
+- The score rides in the event's `data.confidence` field — no new storage required.
+- A **gate** (`workstreams confidence --min-score N`) exits `0` when the latest score is at/above the threshold and `1` otherwise, so it drops straight into CI or a `--wait` loop.
+- Scores are clamped to `[0, 10]`; a misbehaving subagent can't emit `100`.
+
+### Emitting a score
+
+```bash
+# a subagent reports it finished, 9/10 confident
+workstreams event completed --project myproj --workstream 1 \
+    --subagent claude-code --issue 42 \
+    --message "All tests green, edge cases covered" \
+    --confidence 9
+
+# or via --data JSON
+workstreams event completed --project myproj --workstream 1 \
+    --subagent codex --issue 42 --message "Done" --data '{"confidence": 7}'
+
+# Python API (in a subagent script)
+from workstreams import subagent_report
+subagent_report("myproj", 1, "claude-code", 42, "completed", "Done",
+                data={"confidence": 9})
+```
+
+### Reading / gating on scores
+
+```bash
+# human-readable summary + gate (exit 0 if latest >= 8)
+workstreams confidence --project myproj --workstream 1 --issue 42 --min-score 8
+
+# machine-readable
+workstreams confidence --project myproj --workstream 1 --json
+
+# list every confidence-bearing event, oldest first
+workstreams confidence --project myproj --workstream 1 --records
+```
+
+Example output:
+
+```
+Confidence for ws1 #42: PASS
+  latest: 9.0/10 (completed from claude-code)
+  average: 7.0/10 over 2 report(s)
+  threshold: 8.0/10 -> All tests green, edge cases covered
+```
+
+### Using it as a CI / re-dispatch gate
+
+```bash
+# block the merge until the subagent's latest self-rating clears the bar
+workstreams confidence --project myproj --workstream 1 --issue 42 --min-score 9 \
+  || { echo "confidence too low, re-dispatching"; workstreams dispatch ...; }
+```
+
+> Scores are self-reported. Treat them as a *signal*, not a proof — pair them with real test coverage. A 10/10 that shipped a broken build is still a broken build.
+
+---
+
 ## Environment Variables
 
 All are overridable in the config file / CLI; env vars are a fallback when neither is set.
@@ -561,57 +631,21 @@ workstreams logs --workstream 1 --lines 50
 
 ## Architecture
 
-`workstreams` is a thin orchestration layer that sits between you, your git repo, a terminal multiplexer, and any coding agent binary. The core parts and how they fit together:
+`workstreams` is a thin orchestration layer that sits between you, your git repo, a terminal multiplexer, and any coding agent binary.
 
-```
-                 you / your main terminal / a CI job / a cron
-                                   │  CLI (argparse)
-                                   ▼
-        ┌─────────────────────────────────────────────────────────┐
-        │                  cli.py  (entry: workstreams)          │
-        └─────────────────────────────────────────────────────────┘
-        │  command routing          │  config resolution (flag > yaml > env > default)
-        ▼                            ▼
-┌──────────────────────┐   ┌──────────────────────┐
-│  WorkstreamsManager  │   │  config.py            │
-│  (manager.py)        │◄──│  .workstreams.yaml /  │
-│  init·start·dispatch │   │  .json load+save,     │
-│  work·sync·pr·merge· │   │  no-pyyaml fallback   │
-│  run·logs·events     │   └──────────────────────┘
-└──────┬───────────────┘
-       │
-   ┌───┴──────────────────────────────────────────────┐
-   │                                                    │
-   ▼                                                    ▼
-┌────────────────────────────┐          ┌────────────────────────────┐
-│  multiplexer/  (backends)  │          │  event_log.py  +           │
-│  tmux.py / zellij.py       │          │  subagent_client.py        │
-│  MultiplexerBase:          │          │  (Python API emitters)     │
-│   create_session, send_    │          │                            │
-│   command, list_sessions…  │          │  NOTIFIER                  │
-└─────────────┬──────────────┘          │  (notifier.py): desktop    │
-              │ send-keys / tabs        │  notify-send/osascript +   │
-              ▼                         │  notifications.jsonl       │
-      visible terminal panes ◄──────────┤                            │
-      (one per workstream lane)        └────────────────────────────┘
-              │ each pane runs its own agent (claude, codex, …)
-              │ agent appends JSONL events back
-              ▼
-┌──────────────────────────────────────────────────────────────┐
-│  ~/.workstreams/<project>/                                   │
-│    events.jsonl     shared, concurrent-safe event stream     │
-│    notifications.jsonl   cross-terminal notification queue  │
-└──────────────────────────────────────────────────────────────┘
-              ▲
-              │ re-render every 2s (configurable)
-┌────────────────────────────┐
-│  dashboard.py             │
-│  LiveDashboard: ANSI TUI  │  ◄── the only read-side that polls events live
-└────────────────────────────┘
-
-models.py defines the dataclasses (WorkstreamConfig, WorkstreamsConfig,
-WorkstreamStatus, SubagentEvent) shared across all of the above.
-```
+![workstreams architecture](https://github.com/Dream-Pixels-Forge/workstreams-cli/raw/main/assets/workstreams-architecture.webp)
+
+The diagram above shows the full data flow: the CLI routes each command to `WorkstreamsManager`, which talks to a pluggable multiplexer backend to place agents into visible terminal panes, while every lane's subagent writes JSONL events back to a shared, concurrent-safe log that the live dashboard re-renders on a timer. The core modules:
+
+- **`cli.py`** — argparse entry point; every command accepts `--project` and `--json`
+- **`manager.py`** — `WorkstreamsManager` orchestrates init/start/dispatch/work/sync/pr/merge/run/logs/events
+- **`config.py`** — loads/saves `.workstreams.yaml` (or JSON) with no-pyyaml fallback; resolution order: CLI flag > yaml > env > default
+- **`multiplexer/`** — pluggable backends behind `MultiplexerBase` (`tmux.py`, `zellij.py`, plus tmux-compatible wrappers for `nami`/`lmux`/`wmux`/`herdr`)
+- **`event_log.py` + `subagent_client.py`** — shared cross-process JSONL event stream and the Python API emitters
+- **`notifier.py`** — desktop notifications (`notify-send`/`osascript`/PowerShell) plus a `notifications.jsonl` queue
+- **`confidence.py`** — aggregates subagent self-rated 0–10 quality scores for accept / re-dispatch gating
+- **`dashboard.py`** — the live ANSI TUI that polls events and re-renders every 2s
+- **`models.py`** — dataclasses (`WorkstreamConfig`, `WorkstreamsConfig`, `WorkstreamStatus`, `SubagentEvent`) shared across all of the above
 
 How a run flows end-to-end:
 

{workstreams_cli-0.5.1 → workstreams_cli-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "workstreams-cli"
-version = "0.5.1"
+version = "0.6.1"
 description = "Visually dispatch coding-agent work to subagents in real terminal windows and monitor it in one dashboard - for any coding agent (Claude Code, Codex, OpenCode, Qwen Code, Hermes, Cline, and more)."
 readme = "README.md"
 requires-python = ">=3.9"

{workstreams_cli-0.5.1 → workstreams_cli-0.6.1}/src/workstreams/__init__.py

@@ -33,8 +33,16 @@ from .subagent_client import (
     subagent_done,
 )
 from .multiplexer import MultiplexerBase, TmuxMultiplexer, ZellijMultiplexer, get_multiplexer
+from .confidence import (
+    ConfidenceRecord,
+    ConfidenceSummary,
+    get_confidence,
+    confidence_records,
+    clamp_score,
+    extract_score,
+)
 
-__version__ = "0.5.1"
+__version__ = "0.6.1"
 
 __all__ = [
     # models
@@ -68,4 +76,11 @@ __all__ = [
     "TmuxMultiplexer",
     "ZellijMultiplexer",
     "get_multiplexer",
+    # confidence scoring
+    "ConfidenceRecord",
+    "ConfidenceSummary",
+    "get_confidence",
+    "confidence_records",
+    "clamp_score",
+    "extract_score",
 ]

{workstreams_cli-0.5.1 → workstreams_cli-0.6.1}/src/workstreams/cli.py

@@ -208,8 +208,18 @@ def build_parser() -> argparse.ArgumentParser:
     event.add_argument("--issue", type=int, default=0)
     event.add_argument("--message", default="")
     event.add_argument("--data", help="JSON object of extra data (e.g. '{\"files\": 3}')")
+    event.add_argument("--confidence", type=float, default=None, help="Self-rated result quality 0-10 (stored in data.confidence)")
     event.add_argument("--json", action="store_true")
 
+    # confidence (aggregate / gate on subagent self-ratings)
+    confidence = common_parent("confidence")
+    confidence.add_argument("--workstream", type=int, help="Restrict to one workstream")
+    confidence.add_argument("--issue", type=int, help="Restrict to one issue")
+    confidence.add_argument("--subagent", help="Filter by subagent name")
+    confidence.add_argument("--since", type=int, default=43200, help="Minutes back (default: 30 days)")
+    confidence.add_argument("--min-score", type=float, default=8.0, help="Pass threshold for the gate (default: 8.0)")
+    confidence.add_argument("--records", action="store_true", help="List individual confidence-bearing events")
+
     # notify
     notify = common_parent("notify")
     notify.add_argument("--title", required=True)
@@ -412,6 +422,8 @@ def _cmd_event(args) -> int:
         except json.JSONDecodeError:
             print(f"Invalid --data JSON: {args.data}", file=sys.stderr)
             return 2
+    if getattr(args, "confidence", None) is not None:
+        data["confidence"] = args.confidence
     ok = subagent_report(
         project=args.project,
         workstream_id=args.workstream,
@@ -431,6 +443,73 @@ def _cmd_event(args) -> int:
     return 0 if ok else 1
 
 
+def _cmd_confidence(args) -> int:
+    """Aggregate / gate on subagent self-rated confidence scores."""
+    from .confidence import get_confidence, confidence_records, clamp_score
+
+    # clamp the threshold so a bogus --min-score can't break the gate
+    min_score = clamp_score(args.min_score)
+    if min_score is None:
+        print(f"Invalid --min-score: {args.min_score}", file=sys.stderr)
+        return 2
+
+    # The event log is keyed by project, but confidence read commands are
+    # project-scoped like the rest of the read side; fall back to .workstreams.yaml
+    # if no --project was given.
+    import os
+    from .config import load_config
+    project = getattr(args, "project", None)
+    if not project:
+        cfg = load_config(Path.cwd())
+        project = cfg.project
+
+    if args.records:
+        records = confidence_records(
+            project=project,
+            workstream_id=args.workstream,
+            issue=args.issue,
+            subagent=args.subagent,
+            since_minutes=args.since,
+        )
+        if args.json:
+            print(json.dumps([r.to_dict() for r in records], indent=2, default=str))
+            return 0
+        if not records:
+            print(f"(no confidence reports in last {args.since} min)")
+            return 0
+        for r in records:
+            ts = r.timestamp[11:19]
+            print(f"[{ts}] [{r.subagent}] ws{r.workstream_id} #{r.issue} - {r.event_type}: {r.score}/10 {r.message}")
+        return 0
+
+    summary = get_confidence(
+        project=project,
+        workstream_id=args.workstream,
+        issue=args.issue,
+        subagent=args.subagent,
+        since_minutes=args.since,
+        min_score=min_score,
+    )
+    if args.json:
+        print(json.dumps(summary.to_dict(), indent=2, default=str))
+        return 0 if summary.passed else 1
+
+    scope = f"ws{args.workstream}" if args.workstream else "project"
+    if args.issue:
+        scope += f" #{args.issue}"
+    if summary.n_reports == 0:
+        print(f"No confidence reports for {scope} yet.")
+        return 1
+    avg = f"{summary.avg_score:.1f}" if summary.avg_score is not None else "n/a"
+    latest = f"{summary.latest_score:.1f}" if summary.latest_score is not None else "n/a"
+    mark = "PASS" if summary.passed else "FAIL"
+    print(f"Confidence for {scope}: {mark}")
+    print(f"  latest: {latest}/10 ({summary.latest_event_type} from {summary.latest_subagent})")
+    print(f"  average: {avg}/10 over {summary.n_reports} report(s)")
+    print(f"  threshold: {min_score}/10 -> {summary.latest_message}")
+    return 0 if summary.passed else 1
+
+
 def _cmd_notify(args) -> int:
     manager = _load_manager(args)
     manager.notify(args.title, args.message, args.urgency)
@@ -472,6 +551,7 @@ HANDLERS = {
     "tail": _cmd_tail,
     "events": _cmd_events,
     "event": _cmd_event,
+    "confidence": _cmd_confidence,
     "notify": _cmd_notify,
     "assign": _cmd_assign,
     "sync": _cmd_sync,

workstreams_cli-0.6.1/src/workstreams/confidence.py

@@ -0,0 +1,196 @@
+"""Confidence scoring — let subagents self-rate result quality.
+
+A subagent can attach a confidence score (0-10) to any event, signalling
+how sure it is that the delivered result meets the required bar. The main
+agent (or a CI gate) can then query the latest / aggregate confidence and
+decide whether to accept, re-dispatch, or escalate.
+
+    # subagent reports a high-confidence completion
+    workstreams event completed --project p --workstream 1 --subagent claude-code \
+        --issue 42 --message "All tests green" --confidence 9
+
+    # main agent / CI gate: pass only if latest confidence >= 8
+    workstreams confidence --project p --workstream 1 --issue 42 --min-score 8
+    # exit 0 -> gate passed, exit 1 -> below threshold
+
+Scores are read straight from the event log's `data.confidence` field, so
+no new storage is required.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, asdict
+from typing import Any, Dict, List, Optional
+
+from .event_log import get_event_log
+from .models import SubagentEvent
+
+# Confidence scale is 0-10. Anything at/above this is treated as a
+# "high confidence" result by default.
+DEFAULT_MIN_SCORE = 8
+
+
+def clamp_score(value: Any) -> Optional[float]:
+    """Normalise a confidence value to a float in [0, 10], or None.
+
+    Accepts ints, floats, and numeric strings. Values are clamped to
+    [0, 10] so a misbehaving subagent can't emit e.g. 100.
+    """
+    if value is None:
+        return None
+    try:
+        score = float(value)
+    except (TypeError, ValueError):
+        return None
+    if score < 0:
+        return 0.0
+    if score > 10:
+        return 10.0
+    return score
+
+
+@dataclass
+class ConfidenceRecord:
+    """One confidence-bearing event, normalised for display."""
+
+    workstream_id: int
+    subagent: str
+    issue: int
+    event_type: str
+    score: Optional[float]
+    message: str
+    timestamp: str
+    data: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class ConfidenceSummary:
+    """Aggregated confidence view for a workstream (optionally per issue)."""
+
+    workstream_id: int
+    latest_score: Optional[float]
+    latest_event_type: str
+    latest_subagent: str
+    latest_message: str
+    avg_score: Optional[float]
+    n_reports: int
+    passed: bool
+    min_score: float
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+def extract_score(event: SubagentEvent) -> Optional[float]:
+    """Pull a confidence score out of an event (data.confidence preferred)."""
+    score = event.data.get("confidence")
+    if score is None:
+        # also accept top-level 'score' in data for convenience
+        score = event.data.get("score")
+    return clamp_score(score)
+
+
+def get_confidence(
+    project: str,
+    workstream_id: Optional[int] = None,
+    issue: Optional[int] = None,
+    subagent: Optional[str] = None,
+    since_minutes: int = 60 * 24 * 30,  # 30 days
+    min_score: float = DEFAULT_MIN_SCORE,
+) -> ConfidenceSummary:
+    """Aggregate confidence for a workstream (and optional issue/subagent).
+
+    Only events that carry a confidence score are counted. `passed` is True
+    when the *latest* score is at or above `min_score` and at least one
+    scored report exists.
+    """
+    from datetime import datetime, UTC, timedelta
+
+    event_log = get_event_log(project)
+    since = datetime.now(UTC) - timedelta(minutes=since_minutes)
+
+    events = event_log.get_events(
+        workstream_id=workstream_id,
+        since=since,
+        subagent=subagent,
+    )
+    if issue is not None:
+        events = [e for e in events if e.issue == issue]
+
+    scored = [e for e in events if extract_score(e) is not None]
+
+    latest_score: Optional[float] = None
+    latest_event_type = ""
+    latest_subagent = ""
+    latest_message = ""
+    total = 0.0
+    n = 0
+
+    for e in scored:
+        s = extract_score(e)
+        total += s or 0.0
+        n += 1
+        # events are oldest->newest, so the last scored event is the latest
+        latest_score = s
+        latest_event_type = e.event_type
+        latest_subagent = e.subagent
+        latest_message = e.message
+
+    avg_score = (total / n) if n else None
+    passed = (
+        latest_score is not None
+        and latest_score >= min_score
+    )
+
+    return ConfidenceSummary(
+        workstream_id=workstream_id or 0,
+        latest_score=latest_score,
+        latest_event_type=latest_event_type,
+        latest_subagent=latest_subagent,
+        latest_message=latest_message,
+        avg_score=avg_score,
+        n_reports=n,
+        passed=passed,
+        min_score=min_score,
+    )
+
+
+def confidence_records(
+    project: str,
+    workstream_id: Optional[int] = None,
+    issue: Optional[int] = None,
+    subagent: Optional[str] = None,
+    since_minutes: int = 60 * 24 * 30,
+) -> List[ConfidenceRecord]:
+    """Return all confidence-bearing events, oldest first."""
+    from datetime import datetime, UTC, timedelta
+
+    event_log = get_event_log(project)
+    since = datetime.now(UTC) - timedelta(minutes=since_minutes)
+    events = event_log.get_events(
+        workstream_id=workstream_id, since=since, subagent=subagent
+    )
+    if issue is not None:
+        events = [e for e in events if e.issue == issue]
+
+    out: List[ConfidenceRecord] = []
+    for e in events:
+        s = extract_score(e)
+        if s is None:
+            continue
+        out.append(
+            ConfidenceRecord(
+                workstream_id=e.workstream_id,
+                subagent=e.subagent,
+                issue=e.issue,
+                event_type=e.event_type,
+                score=s,
+                message=e.message,
+                timestamp=e.timestamp,
+                data=e.data,
+            )
+        )
+    return out

{workstreams_cli-0.5.1 → workstreams_cli-0.6.1}/src/workstreams/config.py

@@ -47,19 +47,28 @@ def load_config(
     """
     base_path = (base_path or Path.cwd()).resolve()
     config_file = config_path_in(base_path)
+    # Fall back to the JSON config if YAML is not present (no-pyyaml installs)
+    if not config_file.exists():
+        json_fallback = config_file.with_suffix(".json")
+        if json_fallback.exists():
+            config_file = json_fallback
     data: Dict[str, Any] = {}
     if config_file.exists():
         try:
             text = config_file.read_text()
-            parsed = _yaml_load(text)
-            if parsed is not None:
-                data = parsed
+            if config_file.suffix == ".json":
+                parsed = json.loads(text)
+                data = parsed if isinstance(parsed, dict) else {}
             else:
-                # Fallback parser for simple YAML (no pyyaml installed)
-                parsed = _simple_yaml_load(text)
+                parsed = _yaml_load(text)
                 if parsed is not None:
                     data = parsed
-        except OSError:
+                else:
+                    # Fallback parser for simple YAML (no pyyaml installed)
+                    parsed = _simple_yaml_load(text)
+                    if parsed is not None:
+                        data = parsed
+        except (OSError, json.JSONDecodeError):
             data = {}
 
     workstreams = [

{workstreams_cli-0.5.1 → workstreams_cli-0.6.1}/src/workstreams/multiplexer/tmux.py

@@ -180,7 +180,13 @@ class TmuxMultiplexer(MultiplexerBase):
                 flush=True,
             )
             return False
+        # Try the named window first; if tmux can't resolve that target
+        # (stale name, or a session created outside workstreams), fall back
+        # to the numeric window index so dispatches don't silently no-op.
         result = self._tmux("send-keys", "-t", target, command, "Enter")
+        if result.returncode != 0:
+            fallback = f"{self.session}:{workstream_id - 1}"
+            result = self._tmux("send-keys", "-t", fallback, command, "Enter")
         return result.returncode == 0
 
     def capture(self, workstream_id: int, lines: int = 20) -> str:

{workstreams_cli-0.5.1 → workstreams_cli-0.6.1}/src/workstreams_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workstreams-cli
-Version: 0.5.1
+Version: 0.6.1
 Summary: Visually dispatch coding-agent work to subagents in real terminal windows and monitor it in one dashboard - for any coding agent (Claude Code, Codex, OpenCode, Qwen Code, Hermes, Cline, and more).
 Author: Dream-Pixels-Forge
 License: MIT
@@ -45,6 +45,14 @@ Key capabilities:
 - **Cross-terminal notifications** — desktop notifications (Linux `notify-send`, macOS `osascript`) plus a shared `notifications.jsonl` that other terminals can poll
 - **Agent-agnostic** — no vendor lock-in. `dispatch` and `work` send arbitrary shell commands to panes, so it works with whatever agent binary you can run from a shell
 
+## ⭐ If workstreams helps you ship faster, star the repo
+
+If you found this useful, a GitHub star helps other developers discover it.
+
+[![Star on GitHub](https://img.shields.io/github/stars/Dream-Pixels-Forge/workstreams-cli?style=social)](https://github.com/Dream-Pixels-Forge/workstreams-cli)
+
+⭐ **Star this repo:** [github.com/Dream-Pixels-Forge/workstreams-cli](https://github.com/Dream-Pixels-Forge/workstreams-cli)
+
 ## Why this exists
 
 Coding agents increasingly support "subagents" that run in the background of the main agent's process. That means: no visibility (you can't watch them), no isolation (they share one working tree and one set of installed dependencies), no way to run several in parallel on independent branches, and no shared event stream you can watch from your main terminal.
@@ -61,6 +69,7 @@ Coding agents increasingly support "subagents" that run in the background of the
 - [Configuration (.workstreams.yaml)](#configuration-workstreamsyaml)
 - [How the Multiplexers Work](#how-the-multiplexers-work)
 - [Subagent Event System (Python API + CLI)](#subagent-event-system)
+- [Confidence Scoring](#confidence-scoring)
 - [Environment Variables](#environment-variables)
 - [Exit Codes](#exit-codes)
 - [Data Locations](#data-locations)
@@ -105,7 +114,7 @@ pip install -e ".[yaml,dev]"   # dev extras add pytest
 Verify:
 
 ```bash
-workstreams --version   # -> workstreams 0.5.1
+workstreams --version   # -> workstreams 0.6.1
 ```
 
 > **Note:** every command also accepts `--json` to emit machine-readable output (where supported), which coding agents can parse. All read-side commands work without a multiplexer installed; only `start`/`dispatch`/`work`/`attach` need one.
@@ -436,6 +445,67 @@ Events are appended to `~/.workstreams/<project>/events.jsonl` using `O_APPEND`
 
 ---
 
+## Confidence Scoring
+
+Subagents are sometimes wrong. Confidence scoring lets each subagent **self-rate the quality of its result on a 0–10 scale** so the main agent (or a CI gate) can decide whether to accept, re-dispatch, or escalate. It is the difference between "subagent said it's done" and "subagent is 9/10 sure it actually delivered the right result".
+
+- The score rides in the event's `data.confidence` field — no new storage required.
+- A **gate** (`workstreams confidence --min-score N`) exits `0` when the latest score is at/above the threshold and `1` otherwise, so it drops straight into CI or a `--wait` loop.
+- Scores are clamped to `[0, 10]`; a misbehaving subagent can't emit `100`.
+
+### Emitting a score
+
+```bash
+# a subagent reports it finished, 9/10 confident
+workstreams event completed --project myproj --workstream 1 \
+    --subagent claude-code --issue 42 \
+    --message "All tests green, edge cases covered" \
+    --confidence 9
+
+# or via --data JSON
+workstreams event completed --project myproj --workstream 1 \
+    --subagent codex --issue 42 --message "Done" --data '{"confidence": 7}'
+
+# Python API (in a subagent script)
+from workstreams import subagent_report
+subagent_report("myproj", 1, "claude-code", 42, "completed", "Done",
+                data={"confidence": 9})
+```
+
+### Reading / gating on scores
+
+```bash
+# human-readable summary + gate (exit 0 if latest >= 8)
+workstreams confidence --project myproj --workstream 1 --issue 42 --min-score 8
+
+# machine-readable
+workstreams confidence --project myproj --workstream 1 --json
+
+# list every confidence-bearing event, oldest first
+workstreams confidence --project myproj --workstream 1 --records
+```
+
+Example output:
+
+```
+Confidence for ws1 #42: PASS
+  latest: 9.0/10 (completed from claude-code)
+  average: 7.0/10 over 2 report(s)
+  threshold: 8.0/10 -> All tests green, edge cases covered
+```
+
+### Using it as a CI / re-dispatch gate
+
+```bash
+# block the merge until the subagent's latest self-rating clears the bar
+workstreams confidence --project myproj --workstream 1 --issue 42 --min-score 9 \
+  || { echo "confidence too low, re-dispatching"; workstreams dispatch ...; }
+```
+
+> Scores are self-reported. Treat them as a *signal*, not a proof — pair them with real test coverage. A 10/10 that shipped a broken build is still a broken build.
+
+---
+
 ## Environment Variables
 
 All are overridable in the config file / CLI; env vars are a fallback when neither is set.
@@ -591,57 +661,21 @@ workstreams logs --workstream 1 --lines 50
 
 ## Architecture
 
-`workstreams` is a thin orchestration layer that sits between you, your git repo, a terminal multiplexer, and any coding agent binary. The core parts and how they fit together:
+`workstreams` is a thin orchestration layer that sits between you, your git repo, a terminal multiplexer, and any coding agent binary.
 
-```
-                 you / your main terminal / a CI job / a cron
-                                   │  CLI (argparse)
-                                   ▼
-        ┌─────────────────────────────────────────────────────────┐
-        │                  cli.py  (entry: workstreams)          │
-        └─────────────────────────────────────────────────────────┘
-        │  command routing          │  config resolution (flag > yaml > env > default)
-        ▼                            ▼
-┌──────────────────────┐   ┌──────────────────────┐
-│  WorkstreamsManager  │   │  config.py            │
-│  (manager.py)        │◄──│  .workstreams.yaml /  │
-│  init·start·dispatch │   │  .json load+save,     │
-│  work·sync·pr·merge· │   │  no-pyyaml fallback   │
-│  run·logs·events     │   └──────────────────────┘
-└──────┬───────────────┘
-       │
-   ┌───┴──────────────────────────────────────────────┐
-   │                                                    │
-   ▼                                                    ▼
-┌────────────────────────────┐          ┌────────────────────────────┐
-│  multiplexer/  (backends)  │          │  event_log.py  +           │
-│  tmux.py / zellij.py       │          │  subagent_client.py        │
-│  MultiplexerBase:          │          │  (Python API emitters)     │
-│   create_session, send_    │          │                            │
-│   command, list_sessions…  │          │  NOTIFIER                  │
-└─────────────┬──────────────┘          │  (notifier.py): desktop    │
-              │ send-keys / tabs        │  notify-send/osascript +   │
-              ▼                         │  notifications.jsonl       │
-      visible terminal panes ◄──────────┤                            │
-      (one per workstream lane)        └────────────────────────────┘
-              │ each pane runs its own agent (claude, codex, …)
-              │ agent appends JSONL events back
-              ▼
-┌──────────────────────────────────────────────────────────────┐
-│  ~/.workstreams/<project>/                                   │
-│    events.jsonl     shared, concurrent-safe event stream     │
-│    notifications.jsonl   cross-terminal notification queue  │
-└──────────────────────────────────────────────────────────────┘
-              ▲
-              │ re-render every 2s (configurable)
-┌────────────────────────────┐
-│  dashboard.py             │
-│  LiveDashboard: ANSI TUI  │  ◄── the only read-side that polls events live
-└────────────────────────────┘
-
-models.py defines the dataclasses (WorkstreamConfig, WorkstreamsConfig,
-WorkstreamStatus, SubagentEvent) shared across all of the above.
-```
+![workstreams architecture](https://github.com/Dream-Pixels-Forge/workstreams-cli/raw/main/assets/workstreams-architecture.webp)
+
+The diagram above shows the full data flow: the CLI routes each command to `WorkstreamsManager`, which talks to a pluggable multiplexer backend to place agents into visible terminal panes, while every lane's subagent writes JSONL events back to a shared, concurrent-safe log that the live dashboard re-renders on a timer. The core modules:
+
+- **`cli.py`** — argparse entry point; every command accepts `--project` and `--json`
+- **`manager.py`** — `WorkstreamsManager` orchestrates init/start/dispatch/work/sync/pr/merge/run/logs/events
+- **`config.py`** — loads/saves `.workstreams.yaml` (or JSON) with no-pyyaml fallback; resolution order: CLI flag > yaml > env > default
+- **`multiplexer/`** — pluggable backends behind `MultiplexerBase` (`tmux.py`, `zellij.py`, plus tmux-compatible wrappers for `nami`/`lmux`/`wmux`/`herdr`)
+- **`event_log.py` + `subagent_client.py`** — shared cross-process JSONL event stream and the Python API emitters
+- **`notifier.py`** — desktop notifications (`notify-send`/`osascript`/PowerShell) plus a `notifications.jsonl` queue
+- **`confidence.py`** — aggregates subagent self-rated 0–10 quality scores for accept / re-dispatch gating
+- **`dashboard.py`** — the live ANSI TUI that polls events and re-renders every 2s
+- **`models.py`** — dataclasses (`WorkstreamConfig`, `WorkstreamsConfig`, `WorkstreamStatus`, `SubagentEvent`) shared across all of the above
 
 How a run flows end-to-end:
 

{workstreams_cli-0.5.1 → workstreams_cli-0.6.1}/src/workstreams_cli.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 pyproject.toml
 src/workstreams/__init__.py
 src/workstreams/cli.py
+src/workstreams/confidence.py
 src/workstreams/config.py
 src/workstreams/dashboard.py
 src/workstreams/event_log.py
@@ -21,6 +22,7 @@ src/workstreams_cli.egg-info/dependency_links.txt
 src/workstreams_cli.egg-info/entry_points.txt
 src/workstreams_cli.egg-info/requires.txt
 src/workstreams_cli.egg-info/top_level.txt
+tests/test_confidence.py
 tests/test_config.py
 tests/test_event_log.py
 tests/test_models.py

workstreams_cli-0.6.1/tests/test_confidence.py

@@ -0,0 +1,185 @@
+"""Tests for confidence scoring (0-10 self-rated result quality)."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
+
+from workstreams.confidence import (
+    clamp_score,
+    confidence_records,
+    extract_score,
+    get_confidence,
+)
+from workstreams.models import SubagentEvent
+from workstreams.event_log import EventLog
+
+
+def _mk_event(score=None, subagent="claude-code", issue=7, event_type="completed", ws=1):
+    data = {}
+    if score is not None:
+        data["confidence"] = score
+    return SubagentEvent(
+        workstream_id=ws,
+        subagent=subagent,
+        issue=issue,
+        event_type=event_type,
+        message="msg",
+        data=data,
+    )
+
+
+# ---------------------------------------------------------------------------
+# clamp_score
+# ---------------------------------------------------------------------------
+
+def test_clamp_score_none():
+    assert clamp_score(None) is None
+
+
+def test_clamp_score_valid_range():
+    assert clamp_score(5) == 5.0
+    assert clamp_score("7.5") == 7.5
+    assert clamp_score(0) == 0.0
+    assert clamp_score(10) == 10.0
+
+
+def test_clamp_score_clamps_out_of_range():
+    assert clamp_score(-3) == 0.0
+    assert clamp_score(100) == 10.0
+
+
+def test_clamp_score_garbage_is_none():
+    assert clamp_score("not-a-number") is None
+    assert clamp_score([1, 2]) is None
+
+
+# ---------------------------------------------------------------------------
+# extract_score
+# ---------------------------------------------------------------------------
+
+def test_extract_score_reads_confidence():
+    assert extract_score(_mk_event(score=8)) == 8.0
+
+
+def test_extract_score_reads_score_key_too():
+    e = SubagentEvent(workstream_id=1, subagent="x", issue=1, event_type="completed", message="", data={"score": 6})
+    assert extract_score(e) == 6.0
+
+
+def test_extract_score_missing_returns_none():
+    assert extract_score(_mk_event(score=None)) is None
+
+
+# ---------------------------------------------------------------------------
+# get_confidence aggregation
+# ---------------------------------------------------------------------------
+
+def test_get_confidence_pass(tmp_path, monkeypatch):
+    monkeypatch.setenv("WORKSTREAMS_DATA_DIR", str(tmp_path))
+    from workstreams import event_log
+    event_log._log_cache.clear()
+
+    log = EventLog("p", log_dir=tmp_path / "p")
+    log.append(_mk_event(score=5))
+    log.append(_mk_event(score=9))
+
+    summary = get_confidence("p", workstream_id=1, issue=7, min_score=8)
+    assert summary.passed is True
+    assert summary.latest_score == 9.0
+    assert summary.n_reports == 2
+    assert summary.avg_score == pytest.approx(7.0)
+
+
+def test_get_confidence_fail(tmp_path, monkeypatch):
+    monkeypatch.setenv("WORKSTREAMS_DATA_DIR", str(tmp_path))
+    from workstreams import event_log
+    event_log._log_cache.clear()
+
+    log = EventLog("p", log_dir=tmp_path / "p")
+    log.append(_mk_event(score=3))
+
+    summary = get_confidence("p", workstream_id=1, issue=7, min_score=8)
+    assert summary.passed is False
+    assert summary.latest_score == 3.0
+
+
+def test_get_confidence_no_reports(tmp_path, monkeypatch):
+    monkeypatch.setenv("WORKSTREAMS_DATA_DIR", str(tmp_path))
+    from workstreams import event_log
+    event_log._log_cache.clear()
+
+    log = EventLog("p", log_dir=tmp_path / "p")
+    log.append(SubagentEvent(workstream_id=1, subagent="x", issue=7, event_type="started", message="", data={}))
+
+    summary = get_confidence("p", workstream_id=1, issue=7, min_score=8)
+    assert summary.n_reports == 0
+    assert summary.passed is False
+    assert summary.latest_score is None
+
+
+def test_get_confidence_filters_unscored_events(tmp_path, monkeypatch):
+    monkeypatch.setenv("WORKSTREAMS_DATA_DIR", str(tmp_path))
+    from workstreams import event_log
+    event_log._log_cache.clear()
+
+    log = EventLog("p", log_dir=tmp_path / "p")
+    log.append(_mk_event(score=None))          # no confidence -> ignored
+    log.append(_mk_event(score=10, subagent="codex"))
+
+    summary = get_confidence("p", workstream_id=1, issue=7, min_score=8)
+    assert summary.n_reports == 1
+    assert summary.latest_subagent == "codex"
+
+
+def test_get_confidence_issue_filter(tmp_path, monkeypatch):
+    monkeypatch.setenv("WORKSTREAMS_DATA_DIR", str(tmp_path))
+    from workstreams import event_log
+    event_log._log_cache.clear()
+
+    log = EventLog("p", log_dir=tmp_path / "p")
+    log.append(SubagentEvent(workstream_id=1, subagent="a", issue=1, event_type="completed", message="", data={"confidence": 2}))
+    log.append(SubagentEvent(workstream_id=1, subagent="a", issue=2, event_type="completed", message="", data={"confidence": 9}))
+
+    s1 = get_confidence("p", workstream_id=1, issue=1, min_score=8)
+    s2 = get_confidence("p", workstream_id=1, issue=2, min_score=8)
+    assert s1.latest_score == 2.0 and s1.passed is False
+    assert s2.latest_score == 9.0 and s2.passed is True
+
+
+# ---------------------------------------------------------------------------
+# confidence_records
+# ---------------------------------------------------------------------------
+
+def test_confidence_records_oldest_first(tmp_path, monkeypatch):
+    monkeypatch.setenv("WORKSTREAMS_DATA_DIR", str(tmp_path))
+    from workstreams import event_log
+    event_log._log_cache.clear()
+
+    log = EventLog("p", log_dir=tmp_path / "p")
+    log.append(_mk_event(score=1, subagent="a"))
+    log.append(_mk_event(score=5, subagent="b"))
+    log.append(_mk_event(score=9, subagent="c"))
+
+    records = confidence_records("p", workstream_id=1, issue=7)
+    assert [r.subagent for r in records] == ["a", "b", "c"]
+    assert [r.score for r in records] == [1.0, 5.0, 9.0]
+
+
+def test_confidence_records_excludes_unscored(tmp_path, monkeypatch):
+    monkeypatch.setenv("WORKSTREAMS_DATA_DIR", str(tmp_path))
+    from workstreams import event_log
+    event_log._log_cache.clear()
+
+    log = EventLog("p", log_dir=tmp_path / "p")
+    log.append(_mk_event(score=None, subagent="no-score"))
+    log.append(_mk_event(score=7, subagent="scored"))
+
+    records = confidence_records("p", workstream_id=1, issue=7)
+    assert [r.subagent for r in records] == ["scored"]

{workstreams_cli-0.5.1 → workstreams_cli-0.6.1}/tests/test_config.py

@@ -67,6 +67,40 @@ def test_load_nonexistent_returns_default_project(tmp_path):
     assert loaded.multiplexer == "tmux"
 
 
+def test_load_json_when_no_yaml_present(tmp_path):
+    """Regression: when the on-disk config is .json (no pyyaml), load_config
+    must still read it back instead of silently defaulting to 0 workstreams.
+
+    This is the path that caused `start` to create a misnamed session with a
+    `wsNone` window: the workstream list was empty because the JSON file was
+    never consulted."""
+    cfg = _make_config(n=2)
+    project_dir = tmp_path / "jsonproj"
+    project_dir.mkdir()
+    # Save with pyyaml (writes .yaml), then remove the .yaml so only .json
+    # semantics remain — emulate an install without pyyaml.
+    saved = save_config(cfg, project_dir)
+    json_fallback = project_dir / ".workstreams.json"
+    if saved.suffix == ".yaml":
+        # Convert: write the equivalent JSON and drop the YAML so the loader
+        # is forced down the .json branch.
+        import json as _json
+        data = _json.loads(_json.dumps(cfg.to_dict()))
+        json_fallback.write_text(_json.dumps(data, indent=2) + "\n")
+        saved.unlink()
+    else:
+        json_fallback = saved
+
+    loaded = load_config(project_dir, "testproj")
+    assert loaded is not None
+    assert loaded.project == "testproj"
+    assert len(loaded.workstreams) == 2, (
+        f"expected 2 workstreams from JSON config, got {len(loaded.workstreams)}"
+    )
+    assert loaded.workstreams[0].name == "ws1"
+    assert loaded.workstreams[1].branch == "ws/2"
+
+
 def test_load_from_json_fallback(tmp_path):
     """When pyyaml is unavailable the config is saved as .json and must still load."""
     cfg = _make_config(n=1)