workstreams-cli 0.5.0__tar.gz → 0.6.0__tar.gz

{workstreams_cli-0.5.0 → workstreams_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workstreams-cli
-Version: 0.5.0
+Version: 0.6.0
 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)
@@ -68,6 +77,7 @@ Coding agents increasingly support "subagents" that run in the background of the
 - [CI/CD Integration](#cicd-integration)
 - [Troubleshooting](#troubleshooting)
 - [Best Practices](#best-practices)
+- [Architecture](#architecture)
 - [Contributing & License](#contributing--license)
 
 ---
@@ -104,7 +114,7 @@ pip install -e ".[yaml,dev]"   # dev extras add pytest
 Verify:
 
 ```bash
-workstreams --version   # -> workstreams 0.5.0
+workstreams --version   # -> workstreams 0.6.0
 ```
 
 > **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.
@@ -435,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.
@@ -588,28 +659,34 @@ workstreams logs --workstream 1 --lines 50
 
 ---
 
-## Repository Layout
+## Architecture
 
-```
-workstreams-cli/
-├── src/workstreams/
-│   ├── __init__.py         # public API (models, manager, event fns, multiplexers)
-│   ├── cli.py              # argparse CLI (entry: workstreams.cli:main)
-│   ├── config.py           # YAML/JSON config load+save (with no-pyyaml fallback)
-│   ├── models.py           # dataclasses: WorkstreamConfig, WorkstreamsConfig,
-│   │                       #   WorkstreamStatus, SubagentEvent
-│   ├── manager.py          # WorkstreamsManager: init/start/dispatch/work/
-│   │                       #   sync/pr/merge/run/logs/events/notify
-│   ├── event_log.py        # append-only JSONL event log (concurrent-safe)
-│   ├── notifier.py         # desktop + file notifications
-│   ├── dashboard.py        # live ANSI TUI monitor
-│   ├── subagent_client.py  # subagent_* event emitters (Python API)
-│   └── multiplexer/        # tmux + zellij backends (MultiplexerBase)
-├── skills/                 # agent skill: SKILL.md, REFERENCE.md, EXAMPLES.md
-├── scripts/                # standalone script variants + helpers
-├── pyproject.toml          # packaging (pip install workstreams-cli)
-└── .github/workflows/      # PyPI release on GitHub Release (OIDC)
-```
+`workstreams` is a thin orchestration layer that sits between you, your git repo, a terminal multiplexer, and any coding agent binary.
+
+![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:
+
+1. **`init`** creates the lanes: for each workstream it adds a git worktree/branch (`ws/N`) plus a `worktrees/N/` directory, then writes `.workstreams.yaml` in the repo root.
+2. **`start`** asks the chosen multiplexer backend (tmux by default) to open a detached, auto-named session `workstreams-<project>`, one window/tab per lane, each holding a persistent shell.
+3. **`dispatch` / `work` / `run`** target a specific lane's pane (`<session>:<window-name>` for tmux windows, pane index for tiled) and send a command/prompt into it, emitting a `started` event to the shared log and firing a notification.
+4. **Any** process — the agent inside a pane, a CI job, a script, the main terminal — appends JSONL events (`started`, `progress`, `completed`, `failed`, `error`, `done`) to `events.jsonl` using `O_APPEND` plus a short lock that self-heals stale locks after 10s, so concurrent writers never corrupt the stream.
+5. **`monitor`** (the dashboard) and **`events`** read that stream back and re-render every 2s; `--wait` on `dispatch`/`work` blocks until a terminal event arrives (4h safety timeout).
+6. **`sync` / `pr` / `merge` / `workstream cleanup`** close the loop: rebase/merge the lane, push and open a PR via `gh`, merge it, and prune the finished worktree.
+
+Read-side commands (`status`, `events`, `logs`, `monitor`) need no multiplexer; only `start`/`dispatch`/`work`/`attach` require one to be installed.
 
 ---
 

{workstreams_cli-0.5.0 → workstreams_cli-0.6.0}/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)
@@ -38,6 +47,7 @@ Coding agents increasingly support "subagents" that run in the background of the
 - [CI/CD Integration](#cicd-integration)
 - [Troubleshooting](#troubleshooting)
 - [Best Practices](#best-practices)
+- [Architecture](#architecture)
 - [Contributing & License](#contributing--license)
 
 ---
@@ -74,7 +84,7 @@ pip install -e ".[yaml,dev]"   # dev extras add pytest
 Verify:
 
 ```bash
-workstreams --version   # -> workstreams 0.5.0
+workstreams --version   # -> workstreams 0.6.0
 ```
 
 > **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.
@@ -405,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.
@@ -558,28 +629,34 @@ workstreams logs --workstream 1 --lines 50
 
 ---
 
-## Repository Layout
+## Architecture
 
-```
-workstreams-cli/
-├── src/workstreams/
-│   ├── __init__.py         # public API (models, manager, event fns, multiplexers)
-│   ├── cli.py              # argparse CLI (entry: workstreams.cli:main)
-│   ├── config.py           # YAML/JSON config load+save (with no-pyyaml fallback)
-│   ├── models.py           # dataclasses: WorkstreamConfig, WorkstreamsConfig,
-│   │                       #   WorkstreamStatus, SubagentEvent
-│   ├── manager.py          # WorkstreamsManager: init/start/dispatch/work/
-│   │                       #   sync/pr/merge/run/logs/events/notify
-│   ├── event_log.py        # append-only JSONL event log (concurrent-safe)
-│   ├── notifier.py         # desktop + file notifications
-│   ├── dashboard.py        # live ANSI TUI monitor
-│   ├── subagent_client.py  # subagent_* event emitters (Python API)
-│   └── multiplexer/        # tmux + zellij backends (MultiplexerBase)
-├── skills/                 # agent skill: SKILL.md, REFERENCE.md, EXAMPLES.md
-├── scripts/                # standalone script variants + helpers
-├── pyproject.toml          # packaging (pip install workstreams-cli)
-└── .github/workflows/      # PyPI release on GitHub Release (OIDC)
-```
+`workstreams` is a thin orchestration layer that sits between you, your git repo, a terminal multiplexer, and any coding agent binary.
+
+![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:
+
+1. **`init`** creates the lanes: for each workstream it adds a git worktree/branch (`ws/N`) plus a `worktrees/N/` directory, then writes `.workstreams.yaml` in the repo root.
+2. **`start`** asks the chosen multiplexer backend (tmux by default) to open a detached, auto-named session `workstreams-<project>`, one window/tab per lane, each holding a persistent shell.
+3. **`dispatch` / `work` / `run`** target a specific lane's pane (`<session>:<window-name>` for tmux windows, pane index for tiled) and send a command/prompt into it, emitting a `started` event to the shared log and firing a notification.
+4. **Any** process — the agent inside a pane, a CI job, a script, the main terminal — appends JSONL events (`started`, `progress`, `completed`, `failed`, `error`, `done`) to `events.jsonl` using `O_APPEND` plus a short lock that self-heals stale locks after 10s, so concurrent writers never corrupt the stream.
+5. **`monitor`** (the dashboard) and **`events`** read that stream back and re-render every 2s; `--wait` on `dispatch`/`work` blocks until a terminal event arrives (4h safety timeout).
+6. **`sync` / `pr` / `merge` / `workstream cleanup`** close the loop: rebase/merge the lane, push and open a PR via `gh`, merge it, and prune the finished worktree.
+
+Read-side commands (`status`, `events`, `logs`, `monitor`) need no multiplexer; only `start`/`dispatch`/`work`/`attach` require one to be installed.
 
 ---
 

{workstreams_cli-0.5.0 → workstreams_cli-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "workstreams-cli"
-version = "0.5.0"
+version = "0.6.0"
 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.0 → workstreams_cli-0.6.0}/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.0"
+__version__ = "0.6.0"
 
 __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.0 → workstreams_cli-0.6.0}/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.0/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.0 → workstreams_cli-0.6.0}/src/workstreams_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workstreams-cli
-Version: 0.5.0
+Version: 0.6.0
 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)
@@ -68,6 +77,7 @@ Coding agents increasingly support "subagents" that run in the background of the
 - [CI/CD Integration](#cicd-integration)
 - [Troubleshooting](#troubleshooting)
 - [Best Practices](#best-practices)
+- [Architecture](#architecture)
 - [Contributing & License](#contributing--license)
 
 ---
@@ -104,7 +114,7 @@ pip install -e ".[yaml,dev]"   # dev extras add pytest
 Verify:
 
 ```bash
-workstreams --version   # -> workstreams 0.5.0
+workstreams --version   # -> workstreams 0.6.0
 ```
 
 > **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.
@@ -435,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.
@@ -588,28 +659,34 @@ workstreams logs --workstream 1 --lines 50
 
 ---
 
-## Repository Layout
+## Architecture
 
-```
-workstreams-cli/
-├── src/workstreams/
-│   ├── __init__.py         # public API (models, manager, event fns, multiplexers)
-│   ├── cli.py              # argparse CLI (entry: workstreams.cli:main)
-│   ├── config.py           # YAML/JSON config load+save (with no-pyyaml fallback)
-│   ├── models.py           # dataclasses: WorkstreamConfig, WorkstreamsConfig,
-│   │                       #   WorkstreamStatus, SubagentEvent
-│   ├── manager.py          # WorkstreamsManager: init/start/dispatch/work/
-│   │                       #   sync/pr/merge/run/logs/events/notify
-│   ├── event_log.py        # append-only JSONL event log (concurrent-safe)
-│   ├── notifier.py         # desktop + file notifications
-│   ├── dashboard.py        # live ANSI TUI monitor
-│   ├── subagent_client.py  # subagent_* event emitters (Python API)
-│   └── multiplexer/        # tmux + zellij backends (MultiplexerBase)
-├── skills/                 # agent skill: SKILL.md, REFERENCE.md, EXAMPLES.md
-├── scripts/                # standalone script variants + helpers
-├── pyproject.toml          # packaging (pip install workstreams-cli)
-└── .github/workflows/      # PyPI release on GitHub Release (OIDC)
-```
+`workstreams` is a thin orchestration layer that sits between you, your git repo, a terminal multiplexer, and any coding agent binary.
+
+![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:
+
+1. **`init`** creates the lanes: for each workstream it adds a git worktree/branch (`ws/N`) plus a `worktrees/N/` directory, then writes `.workstreams.yaml` in the repo root.
+2. **`start`** asks the chosen multiplexer backend (tmux by default) to open a detached, auto-named session `workstreams-<project>`, one window/tab per lane, each holding a persistent shell.
+3. **`dispatch` / `work` / `run`** target a specific lane's pane (`<session>:<window-name>` for tmux windows, pane index for tiled) and send a command/prompt into it, emitting a `started` event to the shared log and firing a notification.
+4. **Any** process — the agent inside a pane, a CI job, a script, the main terminal — appends JSONL events (`started`, `progress`, `completed`, `failed`, `error`, `done`) to `events.jsonl` using `O_APPEND` plus a short lock that self-heals stale locks after 10s, so concurrent writers never corrupt the stream.
+5. **`monitor`** (the dashboard) and **`events`** read that stream back and re-render every 2s; `--wait` on `dispatch`/`work` blocks until a terminal event arrives (4h safety timeout).
+6. **`sync` / `pr` / `merge` / `workstream cleanup`** close the loop: rebase/merge the lane, push and open a PR via `gh`, merge it, and prune the finished worktree.
+
+Read-side commands (`status`, `events`, `logs`, `monitor`) need no multiplexer; only `start`/`dispatch`/`work`/`attach` require one to be installed.
 
 ---
 

{workstreams_cli-0.5.0 → workstreams_cli-0.6.0}/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.0/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"]