From a458bc222ca75d84045a0effafececefea9586fc Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 18 Oct 2026 15:59:04 +0000
Subject: [PATCH 01/19] delphi: sync .delphi/ from main

---
 .delphi/.gitattributes                        |   2 +
 .delphi/.gitignore                            |   3 +
 .delphi/manifest.yml                          |  22 ++++
 .../0.0.1-linked-worktrees-to-clones.sh       |  20 +++
 .delphi/migrations/0.1.0-path-names.sh        |  29 +++++
 .delphi/new-worktree.sh                       |  23 ++++
 .delphi/park.sh                               |  38 ++++++
 .delphi/paths.sh                              |  15 +++
 .delphi/plugins.sh                            |  78 +++++++++++
 .delphi/setup.sh                              | 123 ++++++++++++++++++
 .delphi/switch.sh                             |  38 ++++++
 .delphi/version.sh                            |  23 ++++
 .delphi/versions                              |  14 ++
 13 files changed, 428 insertions(+)
 create mode 100644 .delphi/.gitattributes
 create mode 100644 .delphi/.gitignore
 create mode 100644 .delphi/manifest.yml
 create mode 100644 .delphi/migrations/0.0.1-linked-worktrees-to-clones.sh
 create mode 100644 .delphi/migrations/0.1.0-path-names.sh
 create mode 100755 .delphi/new-worktree.sh
 create mode 100755 .delphi/park.sh
 create mode 100644 .delphi/paths.sh
 create mode 100755 .delphi/plugins.sh
 create mode 100755 .delphi/setup.sh
 create mode 100755 .delphi/switch.sh
 create mode 100644 .delphi/version.sh
 create mode 100644 .delphi/versions

diff --git a/.delphi/.gitattributes b/.delphi/.gitattributes
new file mode 100644
index 0000000..49724b5
--- /dev/null
+++ b/.delphi/.gitattributes
@@ -0,0 +1,2 @@
+# LF, so these scripts run in Git Bash even with core.autocrlf=true
+* text eol=lf
diff --git a/.delphi/.gitignore b/.delphi/.gitignore
new file mode 100644
index 0000000..918f4a9
--- /dev/null
+++ b/.delphi/.gitignore
@@ -0,0 +1,3 @@
+# Parked workspaces (.delphi/park.sh): this clone's own, never committed. Ignored files are
+# what `git clean -X` and `git stash --all` take, so don't run those at the workspace root.
+/parked/
diff --git a/.delphi/manifest.yml b/.delphi/manifest.yml
new file mode 100644
index 0000000..aa8eb88
--- /dev/null
+++ b/.delphi/manifest.yml
@@ -0,0 +1,22 @@
+# .delphi/manifest.yml: the files that make up a Delphi version, identical on main and on every ws/*
+# branch (sync puts main's .delphi/ on each). Change any of them, this file included, and you make a
+# new version: bump `version` below, then add the line `bash .delphi/version.sh` prints, plus what
+# changed, to .delphi/versions (ci/check.sh fails until you do, and says so). MAJOR.MINOR.PATCH:
+#   PATCH  fixes and wording
+#   MINOR  something new that existing clones need nothing for
+#   MAJOR  clones need cleanup (MINOR while 0.x): add .delphi/migrations/<version>-<slug>.sh, which
+#          setup.sh runs once per workspace in each clone (rules in Delphi's CLAUDE.md)
+version: 0.7.0
+files:                        # repo-relative paths; a trailing / means everything under it
+  - .delphi/manifest.yml
+  - .delphi/.gitattributes
+  - .delphi/.gitignore
+  - .delphi/version.sh
+  - .delphi/setup.sh
+  - .delphi/new-worktree.sh
+  - .delphi/paths.sh
+  - .delphi/plugins.sh
+  - .delphi/switch.sh
+  - .delphi/park.sh
+  - .delphi/migrations/
+  - .github/workflows/delphi.yml
diff --git a/.delphi/migrations/0.0.1-linked-worktrees-to-clones.sh b/.delphi/migrations/0.0.1-linked-worktrees-to-clones.sh
new file mode 100644
index 0000000..fa54838
--- /dev/null
+++ b/.delphi/migrations/0.0.1-linked-worktrees-to-clones.sh
@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# 0.0.1: linked/<name> used to be a worktree of this clone (.delphi/link.sh); setup.sh now makes it a
+# read-only copy. Deletes each old one, and its registration in .git/worktrees/, if nothing in it can
+# be lost: no uncommitted or untracked files, and its commit is on a branch. setup.sh then makes it a
+# copy. Stops, changing nothing more, at the first one that isn't safe to delete.
+set -euo pipefail
+for d in linked/*/; do
+  d=${d%/}
+  [ -f "$d/.git" ] || continue # a read-only copy already, or no checkout at all
+  admin=$(git -C "$d" rev-parse --absolute-git-dir 2>/dev/null) || admin=
+  case "$admin" in */.git/worktrees/*) ;; *)
+    echo "migrate: $d is a broken worktree; move out anything you need, delete it, re-run setup" >&2 && exit 1 ;;
+  esac
+  [ -z "$(git -C "$d" status --porcelain)" ] ||
+    { echo "migrate: $d has uncommitted changes; commit or move them, then re-run setup" >&2 && exit 1; }
+  [ -n "$(git -C "$d" for-each-ref --count=1 --contains HEAD refs/heads refs/remotes)" ] ||
+    { echo "migrate: $d has commits on no branch; git -C $d switch -c <branch>, then re-run setup" >&2 && exit 1; }
+  rm -rf "$d" "$admin"
+  echo "migrate: removed $d, an old link.sh worktree (nothing lost); setup.sh makes it a read-only copy"
+done
diff --git a/.delphi/migrations/0.1.0-path-names.sh b/.delphi/migrations/0.1.0-path-names.sh
new file mode 100644
index 0000000..fe8fa4f
--- /dev/null
+++ b/.delphi/migrations/0.1.0-path-names.sh
@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# 0.1.0: workspaces are named by their place in the tree (ws/software/application-software/argos/argos-dev,
+# was ws/argos-dev), and `links:` is `workspaces:` (`- ws/<name>` or `- main`), copied to linked/<branch>.
+# Moves what this clone keeps under old names to the new ones, for every workspace on main: parked
+# slots (.delphi/parked/<old> and, from before that, .git/delphi/<old>) to .delphi/parked/<name>, and
+# read-only copies linked/<old> to linked/ws/<name>, here and in each parked slot. Only renames; a
+# name taken at both places is reported and left. Your local ws/<old> branch stays; delete it once
+# you're on ws/<name>.
+set -euo pipefail
+git fetch -q origin main 2>/dev/null || echo "migrate: could not fetch main; using the last fetched" >&2
+git rev-parse -q --verify refs/remotes/origin/main >/dev/null ||
+  { echo "migrate: no origin/main here; git fetch origin main, then re-run setup" >&2 && exit 1; }
+names=$(git ls-tree -r --name-only origin/main -- software |
+  sed -nE 's#^(software/(.+/)?)workspaces/([^/]+)/workspace\.yml$#\1\3#p')
+move() { # <from> <to>
+  [ -e "$1" ] || return 0
+  if [ -e "$2" ]; then echo "migrate: $1 and $2 both exist; left $1 (move what you need by hand)" >&2 && return 0; fi
+  mkdir -p "$(dirname "$2")" && mv "$1" "$2" && echo "migrate: moved $1 to $2"
+}
+git_dir=$(git rev-parse --absolute-git-dir)
+for n in $names; do
+  move ".delphi/parked/${n##*/}" ".delphi/parked/$n"
+  move "$git_dir/delphi/${n##*/}" ".delphi/parked/$n"
+  git config --remove-section "delphi.${n##*/}" 2>/dev/null || true # its old version record
+done
+rmdir "$git_dir/delphi" 2>/dev/null || true
+for slot in . $(for n in $names; do [ ! -d ".delphi/parked/$n" ] || echo ".delphi/parked/$n"; done); do
+  for n in $names; do move "$slot/linked/${n##*/}" "$slot/linked/ws/$n"; done
+done
diff --git a/.delphi/new-worktree.sh b/.delphi/new-worktree.sh
new file mode 100755
index 0000000..7760f90
--- /dev/null
+++ b/.delphi/new-worktree.sh
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# .delphi/new-worktree.sh <repo> <branch> [<base>]: create or reuse worktrees/<repo>/<branch> from
+# the store .delphi/setup.sh made at repos/<repo>, and print its path. An existing branch
+# (local or on origin) is checked out; a new one starts from <base> (default: origin's default
+# branch). Runs on bash 3.2 and Git Bash.
+set -euo pipefail
+# shellcheck source-path=SCRIPTDIR source=paths.sh
+. "$(dirname "$0")/paths.sh"
+repo=${1:?usage: new-worktree.sh <repo> <branch> [<base>]} branch=${2:?usage: new-worktree.sh <repo> <branch> [<base>]}
+base=${3:-origin/HEAD} dest="$DELPHI_WORKTREES/$repo/$branch"
+g() { git -C "$DELPHI_REPOS/$repo" "$@"; }
+[ -d "$DELPHI_REPOS/$repo" ] ||
+  { echo "new-worktree: no repos/$repo (list it under repos: and run .delphi/setup.sh; references are read-only)" >&2 && exit 1; }
+g fetch -q origin
+if [ -d "$dest" ]; then :
+elif g rev-parse -q --verify "refs/heads/$branch" >/dev/null; then
+  g worktree add -q "$dest" "$branch"
+elif g rev-parse -q --verify "refs/remotes/origin/$branch" >/dev/null; then
+  g worktree add -q --track -b "$branch" "$dest" "origin/$branch"
+else
+  g worktree add -q --no-track -b "$branch" "$dest" "$base"
+fi
+echo "$dest"
diff --git a/.delphi/park.sh b/.delphi/park.sh
new file mode 100755
index 0000000..cafb387
--- /dev/null
+++ b/.delphi/park.sh
@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# .delphi/park.sh <prev> <new> <branch-flag>: run by the post-checkout hook .delphi/setup.sh writes,
+# from the worktree that checked out. .delphi/ is on every branch, main included, so the hook always
+# finds it, the version just checked out. When a checkout moves this clone to another workspace
+# (the `name:` in workspace.yml, its place in the tree; none on main), it parks the old workspace's
+# root folders (the ones .delphi/paths.sh names, .journal/, and those under `park:` in the workspace.yml
+# of the branch it leaves) at .delphi/parked/<name>/ (git-ignored by .delphi/.gitignore), and brings
+# back everything parked for the new one. A name from before workspaces were named by
+# path (argos-dev) is the same workspace as the path ending in it, so moving onto the renamed branch
+# moves nothing. Moves are renames, so every path is the same again once its workspace is checked
+# out. Runs on bash 3.2 and Git Bash.
+set -euo pipefail
+[ "${3:-0}" = 1 ] || exit 0
+name() { git show "$1:workspace.yml" 2>/dev/null | awk '/^name:/ { print $2; exit }' || true; }
+old=$(name "$1") new=$(name "$2")
+[ "$old" != "$new" ] || exit 0
+case "$old" in */*) ;; ?*) [ "$old" != "${new##*/}" ] || exit 0 ;; esac # renamed by path: still the same workspace
+case "$new" in */*) ;; ?*) [ "$new" != "${old##*/}" ] || exit 0 ;; esac
+top=$(git rev-parse --show-toplevel)
+park=$top/.delphi/parked
+parks() { # <commit>: the root folders its workspace parks
+  echo repos worktrees references linked .journal
+  git show "$1:workspace.yml" 2>/dev/null | awk '/^[^[:space:]#]/ { s = /^park:/; next }
+    s && /^[[:space:]]+-/ { sub(/^[[:space:]]+-[[:space:]]+/, ""); sub(/[[:space:]]*#.*$/, ""); print }' || true
+}
+[ -z "$old" ] || for d in $(parks "$1"); do
+  case "$d" in */* | . | .. | .git | .delphi) echo "delphi: won't park '$d' (park: takes folder names at the root)" >&2 && continue ;; esac
+  [ -e "$top/$d" ] || continue
+  if [ -e "$park/$old/$d" ]; then echo "delphi: $park/$old/$d exists; left $d/ in place" >&2
+  else mkdir -p "$park/$old" && mv "$top/$d" "$park/$old/$d" || echo "delphi: could not park $d/" >&2; fi
+done
+shopt -s nullglob dotglob
+[ -z "$new" ] || for src in "$park/$new"/*; do
+  d=${src##*/}
+  if [ -e "$top/$d" ]; then echo "delphi: $d/ is in the way; $new's is still at $src" >&2
+  else mv "$src" "$top/$d" || echo "delphi: could not restore $d/ from $src" >&2; fi
+done
+[ -z "$new" ] || (cd "$park" 2>/dev/null && rmdir -p "$new" 2>/dev/null) || true # once all back, drop the empty slot
diff --git a/.delphi/paths.sh b/.delphi/paths.sh
new file mode 100644
index 0000000..1c0c27e
--- /dev/null
+++ b/.delphi/paths.sh
@@ -0,0 +1,15 @@
+# .delphi/paths.sh: the workspace layout, in one place. Sourced, it sets and exports DELPHI_ROOT (this
+# clone's top, from this file's place, never by searching) and the folders under it; run, it prints
+# them as one export line. Each harness's session-start hook writes that line into every shell (Claude
+# Code's is in the generated .claude/settings.json), so skill scripts read the workspace from
+# $DELPHI_ROOT and take only names; in a terminal, `. .delphi/paths.sh` from the root. Bash 3.2, Git
+# Bash and zsh safe.
+# shellcheck shell=bash
+DELPHI_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
+DELPHI_REPOS=$DELPHI_ROOT/repos               # bare stores: repos/<repo>
+DELPHI_WORKTREES=$DELPHI_ROOT/worktrees       # checkouts: worktrees/<repo>/<branch>
+DELPHI_REFERENCES=$DELPHI_ROOT/references     # read-only dependency sources: references/<name>
+DELPHI_LINKED=$DELPHI_ROOT/linked             # read-only Delphi copies: linked/<branch>
+export DELPHI_ROOT DELPHI_REPOS DELPHI_WORKTREES DELPHI_REFERENCES DELPHI_LINKED
+[ "${BASH_SOURCE[0]:-}" != "$0" ] || printf 'export DELPHI_ROOT=%q DELPHI_REPOS=%q DELPHI_WORKTREES=%q DELPHI_REFERENCES=%q DELPHI_LINKED=%q\n' \
+  "$DELPHI_ROOT" "$DELPHI_REPOS" "$DELPHI_WORKTREES" "$DELPHI_REFERENCES" "$DELPHI_LINKED"
diff --git a/.delphi/plugins.sh b/.delphi/plugins.sh
new file mode 100755
index 0000000..7449048
--- /dev/null
+++ b/.delphi/plugins.sh
@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+# .delphi/plugins.sh: setup.sh runs it to keep this clone's Delphi plugins in step with this
+# workspace, so a plugin change on main reaches everyone on their next setup, switch or pull, with no
+# migration of its own. Of the `@delphi` plugins (the Delphi marketplace's; others are only warned
+# about), this workspace's generated .claude/settings.json is the list: it installs the ones it
+# enables but this clone hasn't (claude plugin install --scope local, for this root), uninstalls this
+# root's local installs it doesn't enable (a switch leaves the last workspace's behind, still enabled
+# in the git-ignored .claude/settings.local.json), and uninstalls installed ones the marketplace no
+# longer has (Claude Code marks them plugin-not-found), at any scope. Other clones' installs and
+# user-scope ones the marketplace still has are never touched. It refreshes the marketplace before
+# installing or uninstalling what it dropped, only then; if it can't (offline), it does only the
+# local uninstalls and warns about the rest. Installed means at user scope, or at project or local
+# scope for this root. Says what it did in one line; prints nothing when all is in order or it can't
+# tell. Only `harness: claude-code` so far. Finds the workspace from its own place, never by
+# searching. Bash 3.2, Git Bash safe.
+set -euo pipefail
+cd "$(dirname "$0")/.."
+[ -f workspace.yml ] && [ "$(awk '/^harness:/ { print $2; exit }' workspace.yml)" = claude-code ] || exit 0
+command -v claude >/dev/null || exit 0
+enabled=$(sed -nE 's/^[[:space:]]*"([^"]+@[^"]+)": true,?$/\1/p' .claude/settings.json 2>/dev/null || true)
+root=$(pwd -W 2>/dev/null || pwd) # Git Bash: the Windows path Claude Code records
+
+# `<id> <scope> <gone>` for each plugin installed for this root (gone: 1 if its marketplace lost it)
+installed() {
+  claude plugin list --json 2>/dev/null | awk -v root="$root" '
+    function val(l) { sub(/^[^:]*:[[:space:]]*"/, "", l); sub(/"[^"]*$/, "", l); gsub(/\\\\/, "/", l); return l }
+    depth == 1 && /"id":/ { id = val($0); scope = path = ""; gone = 0 }
+    depth == 1 && /"scope":/ { scope = val($0) }
+    depth == 1 && /"projectPath":/ { path = val($0) }
+    /"type":[[:space:]]*"plugin-not-found"/ { gone = 1 }
+    { opened = gsub(/\{/, "{"); closed = gsub(/\}/, "}"); depth += opened - closed }
+    closed && depth == 0 && id != "" { if (scope == "user" || tolower(path) == tolower(root)) print id, scope, gone; id = "" }'
+}
+# What's left to do: `install <id>`, `drop <id>` (a local install here this workspace doesn't enable),
+# `uninstall <id> <scope>` (gone from the marketplace), `missing <id>` (another marketplace's)
+todo() {
+  local have
+  have=$(installed) || return 1
+  for p in $enabled; do
+    echo "$have" | awk -v p="$p" '$1 == p { f = 1 } END { exit !f }' && continue
+    case $p in *@delphi) echo "install $p" ;; *) echo "missing $p" ;; esac
+  done
+  echo "$have" | awk -v on=" ${enabled//$'\n'/ } " '$1 ~ /@delphi$/ {
+    if ($2 == "local" && !index(on, " " $1 " ")) print "drop", $1; else if ($3 == 1) print "uninstall", $1, $2 }'
+}
+work=$(todo) || exit 0
+[ -n "$work" ] || exit 0
+online=""
+if echo "$work" | grep -qE '^(un)?install ' && claude plugin marketplace update delphi >/dev/null 2>&1; then
+  online=1
+  work=$(todo) || exit 0 # again, against the marketplace as it is now
+fi
+did="" left=""
+while read -r verb id scope; do
+  case $verb in
+    drop) claude plugin uninstall "$id" --scope local >/dev/null 2>&1 &&
+      did="$did; uninstalled $id (this workspace doesn't enable it)" || left="$left
+drop $id" ;;
+    install) [ -n "$online" ] && claude plugin install "$id" --scope local >/dev/null 2>&1 &&
+      did="$did; installed $id" || left="$left
+missing $id" ;;
+    uninstall) [ -n "$online" ] && claude plugin uninstall "$id" --scope "$scope" >/dev/null 2>&1 &&
+      did="$did; uninstalled $id (gone from the Delphi marketplace)" || left="$left
+uninstall $id" ;;
+    *) left="$left
+$verb $id" ;;
+  esac
+done <<<"$work"
+[ -z "$did" ] || echo "delphi: plugins: ${did#; }; run /reload-plugins in Claude Code (or restart it) to load the change"
+missing=$(echo "$left" | awk '$1 == "missing" || $1 == "install" { print $2 }' | paste -sd " " -)
+stale=$(echo "$left" | awk '$1 == "uninstall" { print $2 }' | paste -sd " " -)
+extra=$(echo "$left" | awk '$1 == "drop" { print $2 }' | paste -sd " " -)
+[ -z "$missing" ] ||
+  echo "delphi: this workspace's plugins $missing aren't installed here, so their skills are missing; install each with: claude plugin install <plugin> --scope local"
+[ -z "$stale" ] ||
+  echo "delphi: plugins $stale are gone from the Delphi marketplace; uninstall each with: claude plugin uninstall <plugin> --scope <its scope>"
+[ -z "$extra" ] ||
+  echo "delphi: plugins $extra are installed here but this workspace doesn't enable them; uninstall each with: claude plugin uninstall <plugin> --scope local"
diff --git a/.delphi/setup.sh b/.delphi/setup.sh
new file mode 100755
index 0000000..ecb2a62
--- /dev/null
+++ b/.delphi/setup.sh
@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+# .delphi/setup.sh: run in a checkout of ws/<name> (the workspace root; .delphi/ comes from Delphi's
+# main, which sync keeps on every ws/* branch, so edit it only there; on main this does nothing). For each repo listed under
+# `repos:` in workspace.yml, fetches it into a bare store at repos/<name> (unless present) and checks
+# out its default branch as the first worktree, worktrees/<name>/<default-branch>. For each repo under
+# `references-git:` (read-only dependency sources, `<name>: <git-url> [<ref>]`), checks out a shallow,
+# detached copy of <ref> (default: origin's default branch) at references/<name>, refreshed on every
+# run, with pushes disabled. Each entry under `workspaces:` (`- ws/<name>` or `- main`, a workspace
+# being named by its place in the tree) gets the same kind of copy of that branch of this clone's
+# origin (Delphi), at linked/<branch>; to edit one, switch this clone to it (.delphi/switch.sh). Adds the
+# folders park.sh parks and macOS's .DS_Store to this clone's .git/info/exclude, and writes its post-checkout hook, which runs .delphi/park.sh (on
+# every branch) as just checked out in the worktree that checked out (unless another hook is there), so switching
+# to another workspace or main parks those folders. First
+# it runs the .delphi/migrations/<version>-*.sh this workspace hasn't (oldest first; the last one done
+# is `git config delphi.<name>.version`, 0.0.0 if unset), stopping at one that fails, and warns if
+# .delphi/ isn't exactly the version it says (.delphi/version.sh). Last, it brings this machine's Delphi plugins in
+# step with the workspace (.delphi/plugins.sh: installs what it enables, uninstalls local ones it doesn't and what the marketplace dropped). Safe to re-run. Keep it bash 3.2
+# (macOS) and Git Bash safe: no bash-4 features, POSIX awk only.
+set -euo pipefail
+cd "$(dirname "$0")/.."
+[ -f workspace.yml ] || { echo "setup: no workspace.yml here (on main?); nothing to set up" >&2 && exit 0; }
+self=$(awk '/^name:/ { print $2; exit }' workspace.yml)
+case "$self" in "" | [-/]* | */ | *//* | *[!a-z0-9/-]*) echo "setup: workspace.yml needs a valid name:" >&2 && exit 1 ;; esac
+
+older() { # <a> <b>: a is a lower MAJOR.MINOR.PATCH than b
+  [ "$1" != "$2" ] && [ "$(printf '%s\n%s\n' "$1" "$2" | sort -t. -k1,1n -k2,2n -k3,3n | head -n 1)" = "$1" ]
+}
+here=$(bash .delphi/version.sh) released=$(grep -v '^#' .delphi/versions | grep . | tail -n 1 | cut -d' ' -f1,2 || true)
+[ "$here" = "$released" ] ||
+  echo "setup: .delphi/ is not Delphi ${released%% *} as released (edited here? change it only through main)" >&2
+have=$(git config "delphi.$self.version" || echo 0.0.0)
+pending=$(for f in .delphi/migrations/*.sh; do [ ! -e "$f" ] || echo "${f##*/}"; done | sort -t. -k1,1n -k2,2n -k3,3n)
+while IFS= read -r f; do
+  v=${f%%-*}
+  [ -n "$f" ] || continue
+  older "$have" "$v" || continue
+  echo "setup: migrating $self to $v (.delphi/migrations/$f)"
+  bash ".delphi/migrations/$f" </dev/null || { echo "setup: migration $f failed; do what it says, then re-run" >&2 && exit 1; }
+  git config "delphi.$self.version" "$v" && have=$v
+done <<EOF1
+$pending
+EOF1
+! older "$have" "${here%% *}" || git config "delphi.$self.version" "${here%% *}"
+
+list=$(awk '
+  /^[[:space:]]*#/ || /^[[:space:]]*$/ { next }
+  /^repos:/ { s = "repo"; next }
+  /^references-git:/ { s = "ref"; next }
+  /^workspaces:/ { s = "link"; next }
+  /^[^[:space:]]/ { s = "" }
+  s == "link" { sub(/^[[:space:]]*-[[:space:]]*/, ""); sub(/[[:space:]]*#.*$/, ""); print s, $0; next }
+  s { sub(/^[[:space:]]+/, ""); sub(/[[:space:]]+#.*$/, ""); n = index($0, ":")
+      if (n) print s, substr($0, 1, n - 1), substr($0, n + 1) }' workspace.yml)
+
+readonly_copy() { # <dir> <url> [<ref>]: shallow, detached, push-disabled checkout at <dir>
+  local dir=$1
+  [ ! -f "$dir/.git" ] || { echo "setup: $dir is a worktree, not a read-only copy; skipping it" >&2 && return; }
+  [ -d "$dir/.git" ] || { git init -q "$dir" && git -C "$dir" remote add origin "$2"; }
+  git -C "$dir" remote set-url origin "$2"
+  git -C "$dir" remote set-url --push origin DISABLED-read-only-copy
+  if git -C "$dir" fetch -q --depth 1 origin "${3:-HEAD}" </dev/null &&
+    git -C "$dir" checkout -q --detach FETCH_HEAD; then
+    echo "$dir: at ${3:-default branch} ($(git -C "$dir" rev-parse --short HEAD))"
+  else
+    echo "setup: could not update $dir to ${3:-the default branch}" >&2
+  fi
+}
+
+link() { # ws/<name>|main: a read-only copy of that branch of Delphi at linked/<branch>
+  case "$1" in main | ws/[a-z0-9]*) ;; *) echo "setup: skipping bad workspaces: entry '$1'" >&2 && return ;; esac
+  case "$1" in "ws/$self") return ;; */ | *//* | *[!a-z0-9/-]*) echo "setup: skipping bad workspaces: entry '$1'" >&2 && return ;; esac
+  readonly_copy "linked/$1" "$(git remote get-url origin)" "$1"
+}
+
+while read -r kind name url ref; do
+  [ -n "$name" ] || continue
+  if [ "$kind" = link ]; then link "$name"; continue; fi
+  case "$name" in . | .. | *[!A-Za-z0-9._-]*) echo "setup: skipping unsafe repo name '$name'" >&2 && continue ;; esac
+  if [ "$kind" = ref ]; then readonly_copy "references/$name" "$url" ${ref:+"$ref"} && continue; fi
+  store=repos/$name
+  if [ -e "$store" ]; then
+    echo "repos/$name: already present"
+  else
+    git init -q --bare "$store"
+    git -C "$store" remote add origin "$url"
+    git -C "$store" fetch -q origin </dev/null
+    git -C "$store" remote set-head origin -a >/dev/null </dev/null
+  fi
+  def=$(git -C "$store" symbolic-ref -q --short refs/remotes/origin/HEAD) ||
+    { echo "setup: repos/$name has no origin/HEAD; skipping its worktree" >&2 && continue; }
+  def=${def#origin/}
+  dest=worktrees/$name/$def
+  if [ -e "$dest" ]; then continue
+  elif git -C "$store" rev-parse -q --verify "refs/heads/$def" >/dev/null; then
+    git -C "$store" worktree add -q "$PWD/$dest" "$def" ||
+      echo "setup: could not check out $dest (is $def checked out in repos/$name?)" >&2
+  else
+    git -C "$store" worktree add -q --track -b "$def" "$PWD/$dest" "origin/$def"
+  fi
+done <<EOF2
+$list
+EOF2
+
+exclude=$(git rev-parse --git-path info/exclude)
+mkdir -p "$(dirname "$exclude")"
+for d in /repos/ /worktrees/ /references/ /linked/ /.journal/ $(awk '/^[^[:space:]#]/ { s = /^park:/; next }
+  s && /^[[:space:]]+-/ { sub(/^[[:space:]]+-[[:space:]]+/, ""); sub(/[[:space:]]*#.*$/, ""); print "/" $0 "/" }' workspace.yml) .DS_Store; do
+  grep -qxF "$d" "$exclude" 2>/dev/null || echo "$d" >>"$exclude"
+done
+hook=$(git rev-parse --git-path hooks/post-checkout)
+link=$(readlink "$hook" 2>/dev/null || true) # ours: this script, or an old link to (or copy of) a park.sh
+if [ "${link%/.delphi/park.sh}" != "$link" ] || { [ -z "$link" ] && { [ ! -e "$hook" ] || grep -qF '.delphi/park.sh' "$hook"; }; }; then
+  # A script, not a link: the clone's worktrees share one hook, and a link would run one checkout's park.sh for all
+  mkdir -p "$(dirname "$hook")" && rm -f "$hook" && cat >"$hook" <<'EOF3' && chmod +x "$hook"
+#!/bin/sh
+# Delphi's post-checkout hook, written by .delphi/setup.sh: runs .delphi/park.sh as just checked out,
+# in the worktree that checked out (git runs hooks at its root), so each runs its own branch's.
+[ ! -f .delphi/park.sh ] || exec bash .delphi/park.sh "$@"
+EOF3
+else
+  echo "setup: $hook is another hook; not installing .delphi/park.sh, so checkouts won't park repos/" >&2
+fi
+bash .delphi/plugins.sh >&2 || true # never a failure
diff --git a/.delphi/switch.sh b/.delphi/switch.sh
new file mode 100755
index 0000000..0e6afb7
--- /dev/null
+++ b/.delphi/switch.sh
@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# .delphi/switch.sh <workspace>|main: move this clone to Delphi's ws/<workspace> (or main). A workspace
+# is named by its place in the tree (software/application-software/argos/argos-dev; ws/ in front is
+# fine), or by its last part alone (argos-dev) if only one workspace ends in it. Refuses if
+# tracked files have changes (they would follow the switch), fetches the branch, switches to it (the
+# local branch, else a new one tracking origin), fast-forwards it to origin, then runs the new
+# workspace's .delphi/setup.sh (none for main). The post-checkout hook (.delphi/park.sh) parks this workspace's
+# repos/, worktrees/, references/ and linked/ and restores the new one's. Runs on bash 3.2 and Git Bash.
+# .delphi/switch.sh --list: fetch the ws/* branches, then print main and each workspace's name, one a
+# line, `* ` before this clone's and two spaces before the others (the delphi mod's /ws-delphi pane reads it).
+set -euo pipefail
+{ # one block, so bash has read all of it before the switch replaces this file
+  cd "$(dirname "$0")/.."
+  if [ "${1:-}" = --list ]; then
+    git fetch -q --prune origin '+refs/heads/ws/*:refs/remotes/origin/ws/*' ||
+      echo "switch: could not fetch the ws/* branches; listing the ones last fetched" >&2
+    { echo main && git for-each-ref --format='%(refname:lstrip=3)' refs/remotes/origin/ws/; } |
+      awk -v here="$(git branch --show-current)" '$0 == "main" || /^ws\/.*\// { # not ws/<leaf>: an old name
+        n = $0; sub(/^ws\//, "", n); print ($0 == here ? "* " : "  ") n }'
+    exit
+  fi
+  name=${1:?usage: switch.sh <workspace>|main}
+  name=${name#ws/} ref=ws/${name#ws/}
+  case "$name" in main) ref=main ;; "" | [-/]* | */ | *//* | *[!a-z0-9/-]*) echo "switch: bad workspace name '$1'" >&2 && exit 1 ;; esac
+  if [ "$ref" != main ] && [ "$name" = "${name##*/}" ]; then # its last part alone: find the one workspace it names
+    git fetch -q origin '+refs/heads/ws/*:refs/remotes/origin/ws/*' || { echo "switch: could not fetch the ws/* branches" >&2 && exit 1; }
+    ref=$(git for-each-ref --format='%(refname:lstrip=3)' refs/remotes/origin/ws/ | grep "^ws/.*/$name\$" || true) # not ws/<name>: an old name
+    [ -n "$ref" ] && [ "$(echo "$ref" | wc -l)" -eq 1 ] ||
+      { echo "switch: no one workspace ends in '$name' (found: $(echo "${ref:-none}" | tr '\n' ' ')); give its full name" >&2 && exit 1; }
+  fi
+  git diff --quiet HEAD -- || { echo "switch: commit or set aside your changes first (git status)" >&2 && exit 1; }
+  git fetch -q origin "+refs/heads/$ref:refs/remotes/origin/$ref" || { echo "switch: could not fetch $ref" >&2 && exit 1; }
+  git switch -q "$ref"
+  git merge -q --ff-only "origin/$ref" 2>/dev/null || echo "switch: $ref has diverged from origin; not fast-forwarded" >&2
+  [ ! -f workspace.yml ] || bash .delphi/setup.sh
+  echo "switch: on $ref"
+  exit
+}
diff --git a/.delphi/version.sh b/.delphi/version.sh
new file mode 100644
index 0000000..90d982a
--- /dev/null
+++ b/.delphi/version.sh
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# .delphi/version.sh [--files]: prints this checkout's Delphi version, `<version> <hash>`: the
+# `version:` in .delphi/manifest.yml and a hash of the files it lists (their paths and contents as git
+# stores them, so line endings don't change it; tracked files only). The last line of .delphi/versions
+# must match it (ci/check.sh); setup.sh warns when it doesn't. --files: just the listed files, one per
+# line (a listed path git doesn't track is printed as is). Keep it bash 3.2 (macOS) and Git Bash safe.
+set -euo pipefail
+cd "$(dirname "$0")/.."
+m=.delphi/manifest.yml
+files() {
+  awk '/^[[:space:]]*#/ { next } /^files:/ { s = 1; next } /^[^[:space:]]/ { s = 0 }
+    s && /^[[:space:]]+-/ { sub(/^[[:space:]]+-[[:space:]]+/, ""); sub(/[[:space:]]+#.*$/, ""); print }' "$m" |
+    while IFS= read -r p; do
+      l=$(git ls-files -- "$p")
+      if [ -n "$l" ]; then echo "$l"; else echo "$p"; fi
+    done | LC_ALL=C sort -u
+}
+[ "${1:-}" != --files ] || { files && exit; }
+version=$(awk '/^version:/ { print $2; exit }' "$m")
+hash=$(files | while IFS= read -r f; do
+  echo "$(git hash-object -- "$f" 2>/dev/null || echo missing) $f"
+done | git hash-object --stdin | cut -c1-12)
+echo "${version:-none} $hash"
diff --git a/.delphi/versions b/.delphi/versions
new file mode 100644
index 0000000..cab1212
--- /dev/null
+++ b/.delphi/versions
@@ -0,0 +1,14 @@
+# .delphi/versions: one line per Delphi version, oldest first: `<version> <hash> <what changed>`, the
+# hash being that of the files .delphi/manifest.yml lists. Only add lines; `bash .delphi/version.sh`
+# prints the first two fields for the files as they are now.
+0.0.1 1fc1890f7d00 versions and migrations; linked/ are read-only copies, not link.sh worktrees (migration)
+0.1.0 6522fea335e8 workspaces named by their place in the tree (ws/software/.../<name>); links: is workspaces: (- ws/<name> | - main) (migration)
+0.1.1 4829c508fd00 the post-checkout hook is a script running each worktree's own .delphi/park.sh, not a link to one checkout's
+0.2.0 311f7b23606c .delphi/paths.sh is the workspace layout (DELPHI_ROOT, DELPHI_WORKTREES, …): sourced, it exports it; run, it prints the export line a session hook puts in every shell
+0.3.0 2c870f633c30 workspace-inherit/ folders at any level of software/ reach every workspace below on each sync (opt-out: in workspace.yml); defaults/ is workspace-defaults/
+0.4.0 ba662e754219 setup.sh warns (.delphi/plugins.sh) about enabled plugins not installed here; CLAUDE.md says how to install them
+0.4.1 c5e413632e1c setup.sh also excludes what tools leave at the root: /.playwright-mcp/, /pictures/ and .DS_Store
+0.5.0 6088d535fdd9 switch.sh --list prints main and the workspaces, marking this clone's; the delphi mod's /ws pane reads it
+0.5.1 3fd96f222b77 the delphi mod's command is /ws-delphi (was /ws); switch.sh's comment says so
+0.6.0 c65ffc578bfa setup.sh (.delphi/plugins.sh) makes each clone's @delphi plugins what its workspace enables (installs them, uninstalls local ones it doesn't) and uninstalls ones the marketplace dropped, instead of warning; plugin changes need no migration
+0.7.0 84df5ce802db park.sh also parks .journal/ and the root folders under a workspace's park: in workspace.yml (each workspace its own), restores everything parked for a workspace, and skips bad entries; setup.sh excludes them

From d041fd92521fca9124c8139f9ab20892d6e14938 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 18 Oct 2026 15:59:04 +0000
Subject: [PATCH 02/19] delphi: sync inherited files from main

---
 .claude/skills/address-pr-comments/SKILL.md   | 20 ++++++
 .../scripts/fetch-feedback.sh                 | 48 ++++++++++++++
 .../address-pr-comments/scripts/github.sh     | 19 ++++++
 .claude/skills/commit/SKILL.md                |  6 ++
 .claude/skills/consolidate-spikes/SKILL.md    | 13 ++++
 .claude/skills/create-ticket/SKILL.md         | 66 +++++++++++++++++++
 .claude/skills/implement/SKILL.md             | 13 ++++
 .claude/skills/journal/SKILL.md               | 22 +++++++
 .claude/skills/journal/scripts/capture.sh     | 17 +++++
 .claude/skills/new-worktree/SKILL.md          | 15 +++++
 .claude/skills/open-pr/SKILL.md               | 21 ++++++
 .claude/skills/open-pr/scripts/pr-checks.sh   | 23 +++++++
 .claude/skills/pr-conventions/SKILL.md        | 15 +++++
 .claude/skills/pr-conventions/scripts/lint.sh | 15 +++++
 .claude/skills/report-spike/SKILL.md          | 22 +++++++
 .claude/skills/run-local/SKILL.md             | 14 ++++
 .claude/skills/run-local/scripts/run-local.sh | 66 +++++++++++++++++++
 .claude/skills/run-local/scripts/serve.sh     | 43 ++++++++++++
 .claude/skills/setup-workspace/SKILL.md       | 18 +++++
 .claude/skills/switch-workspace/SKILL.md      | 21 ++++++
 .claude/skills/ticket-conventions/SKILL.md    | 15 +++++
 .claude/skills/update-pr/SKILL.md             |  6 ++
 .claude/skills/verify-graph/SKILL.md          | 21 ++++++
 .claude/skills/verify-graph/helpers.js        | 24 +++++++
 .claude/skills/verify-telemetry/SKILL.md      | 16 +++++
 .../verify-telemetry/scripts/check-topic.sh   | 28 ++++++++
 26 files changed, 607 insertions(+)
 create mode 100644 .claude/skills/address-pr-comments/SKILL.md
 create mode 100755 .claude/skills/address-pr-comments/scripts/fetch-feedback.sh
 create mode 100644 .claude/skills/address-pr-comments/scripts/github.sh
 create mode 100644 .claude/skills/commit/SKILL.md
 create mode 100644 .claude/skills/consolidate-spikes/SKILL.md
 create mode 100644 .claude/skills/create-ticket/SKILL.md
 create mode 100644 .claude/skills/implement/SKILL.md
 create mode 100644 .claude/skills/journal/SKILL.md
 create mode 100755 .claude/skills/journal/scripts/capture.sh
 create mode 100644 .claude/skills/new-worktree/SKILL.md
 create mode 100644 .claude/skills/open-pr/SKILL.md
 create mode 100755 .claude/skills/open-pr/scripts/pr-checks.sh
 create mode 100644 .claude/skills/pr-conventions/SKILL.md
 create mode 100644 .claude/skills/pr-conventions/scripts/lint.sh
 create mode 100644 .claude/skills/report-spike/SKILL.md
 create mode 100644 .claude/skills/run-local/SKILL.md
 create mode 100755 .claude/skills/run-local/scripts/run-local.sh
 create mode 100755 .claude/skills/run-local/scripts/serve.sh
 create mode 100644 .claude/skills/setup-workspace/SKILL.md
 create mode 100644 .claude/skills/switch-workspace/SKILL.md
 create mode 100644 .claude/skills/ticket-conventions/SKILL.md
 create mode 100644 .claude/skills/update-pr/SKILL.md
 create mode 100644 .claude/skills/verify-graph/SKILL.md
 create mode 100644 .claude/skills/verify-graph/helpers.js
 create mode 100644 .claude/skills/verify-telemetry/SKILL.md
 create mode 100755 .claude/skills/verify-telemetry/scripts/check-topic.sh

diff --git a/.claude/skills/address-pr-comments/SKILL.md b/.claude/skills/address-pr-comments/SKILL.md
new file mode 100644
index 0000000..30083fa
--- /dev/null
+++ b/.claude/skills/address-pr-comments/SKILL.md
@@ -0,0 +1,20 @@
+---
+name: address-pr-comments
+description: Fetch review comments on a PR (Argos, Nero), judge whether each (including outdated ones) still applies, and walk through fixes in the PR's worktree
+allowed-tools: Bash(git:*), Bash(gh issue list:*), Bash(bash ${CLAUDE_SKILL_DIR}/scripts/fetch-feedback.sh *)
+user-invocable: true
+---
+
+Propose and apply fixes for a PR's unresolved review feedback. **Never reply to threads**; the user does.
+
+1. **Fetch** from the workspace root: `bash scripts/fetch-feedback.sh <repo> <pr>|<branch>` (`<repo>` as under `repos/`, e.g. `argos`; `--all` first for unfiltered history). It checks out the PR head's worktree and prints JSON: `worktree` (target it by path from the root from now on), unresolved `threads`, `comments`, `reviews`. Any non-zero exit: use the GitHub MCP server's `pull_request_read` instead.
+2. **Judge.** Skip bot noise and anything already fixed at HEAD. For an `outdated` thread, find its `diffHunk` code by content, then label it **addressed**, **applies**, **moved**, **obsolete**, or **unclear**.
+3. **Present** before editing, grouped by file, and ask to confirm, skip, or change each (offer to batch clear ones past 8):
+
+   ```
+   <file>:<line> — <reviewer> · <active|outdated> · <label>
+   "<excerpt>" → <proposed fix>
+   <optional ≤5-line snippet, for the user only>
+   ```
+4. **Apply** in that worktree, by path, with grouped `/commit`s. For a follow-up-ticket request, reuse a match from `gh issue list --search` before filing.
+5. **Report** what was fixed (file:line, commit SHA), what was already addressed or obsolete (why), and what is unclear.
diff --git a/.claude/skills/address-pr-comments/scripts/fetch-feedback.sh b/.claude/skills/address-pr-comments/scripts/fetch-feedback.sh
new file mode 100755
index 0000000..1debe03
--- /dev/null
+++ b/.claude/skills/address-pr-comments/scripts/fetch-feedback.sh
@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# fetch-feedback.sh [--all] <repo> <pr-number>|<branch>: print a PR's review
+# feedback as one JSON object after creating or reusing the PR head's worktree
+# (worktrees/<repo>/<head>). Default output keeps unresolved threads (first + latest message,
+# bots tagged), conversation comments, and reviews with text; --all keeps everything. Exits 3 on any
+# GitHub failure (see github.sh).
+# shellcheck source-path=SCRIPTDIR source=github.sh
+set -euo pipefail
+. "$(dirname "$0")/github.sh"
+all=false
+[ "${1:-}" = --all ] && all=true && shift
+usage="usage: fetch-feedback.sh [--all] <repo> <pr-number>|<branch>"
+repo=${1:?$usage} ref=${2:?$usage}
+# shellcheck source=/dev/null
+. "${DELPHI_ROOT:?unset: start the session at the workspace root, on Delphi 0.2.0+ (pull its ws/ branch), or source <root>/.delphi/paths.sh}/.delphi/paths.sh"
+gh_init fetch-feedback "$DELPHI_REPOS/$repo"
+
+case "$ref" in *[!0-9]*) get "repos/$SLUG/pulls?state=all&head=${SLUG%%/*}:$ref" | jq '.[0] // error("no PR")' ;;
+  *) get "repos/$SLUG/pulls/$ref" ;; esac >"$TMP/pr"
+num=$(jq .number "$TMP/pr")
+wt=""
+[ "$(jq -r .head.repo.full_name "$TMP/pr")" != "$SLUG" ] || wt=$(bash "$DELPHI_ROOT/.delphi/new-worktree.sh" "$repo" "$(jq -r .head.ref "$TMP/pr")")
+
+if [ "$MODE" = gh ]; then # thread state is GraphQL-only; reshape it like the proxy's ccr/review_threads
+  # shellcheck disable=SC2016 # GraphQL variables
+  gh api graphql -F o="${SLUG%%/*}" -F n="${SLUG##*/}" -F p="$num" -f query='query($o: String!, $n: String!, $p: Int!) {
+    repository(owner: $o, name: $n) { pullRequest(number: $p) { reviewThreads(first: 100) { nodes {
+      isResolved isOutdated comments(first: 50) { nodes { databaseId } } } } } } }' \
+    --jq '[.data.repository.pullRequest.reviewThreads.nodes[] |
+      {resolved: .isResolved, outdated: .isOutdated, comment_ids: [.comments.nodes[].databaseId]}]'
+else get "repos/$SLUG/pulls/$num/ccr/review_threads"; fi >"$TMP/th"
+get "repos/$SLUG/pulls/$num/comments?per_page=100" >"$TMP/rc"
+get "repos/$SLUG/issues/$num/comments?per_page=100" >"$TMP/ic"
+get "repos/$SLUG/pulls/$num/reviews?per_page=100" >"$TMP/rv"
+
+jq -n --arg wt "$wt" --argjson all "$all" --slurpfile pr "$TMP/pr" --slurpfile th "$TMP/th" \
+  --slurpfile rc "$TMP/rc" --slurpfile ic "$TMP/ic" --slurpfile rv "$TMP/rv" '
+  def who: {author: .user.login, bot: (.user.type == "Bot")};
+  ($rc[0] | map({key: (.id | tostring), value: (who + {body, path, line: (.line // .original_line), diffHunk: .diff_hunk})}) | from_entries) as $byid |
+  {pr: ($pr[0] | {number, title, url: .html_url, head: .head.ref, base: .base.ref}), worktree: $wt,
+   threads: [$th[0][] | {resolved, outdated, comments: [.comment_ids[] | $byid[tostring]]}],
+   comments: [$ic[0][] | who + {body}], reviews: [$rv[0][] | who + {state, body: (.body // "")}]} |
+  if $all then . else
+    .threads |= map(select(.resolved | not) | .comments as $c | $c[-1] + {outdated, path: $c[0].path, line: $c[0].line,
+      diffHunk: (if .outdated then $c[0].diffHunk else null end), replies: ($c | length),
+      first: (if ($c | length) > 1 then $c[0].body else null end)}) |
+    .reviews |= map(select(.body != ""))
+  end'
diff --git a/.claude/skills/address-pr-comments/scripts/github.sh b/.claude/skills/address-pr-comments/scripts/github.sh
new file mode 100644
index 0000000..118d210
--- /dev/null
+++ b/.claude/skills/address-pr-comments/scripts/github.sh
@@ -0,0 +1,19 @@
+# github.sh: sourced by skill scripts that call GitHub. gh_init <tool> <git-dir> picks a backend
+# (gh when logged in, else a Claude Code remote session's REST proxy via curl; jq is needed either
+# way), sets SLUG from that repo's origin, and makes any failure exit 3 so the calling skill falls
+# back to the GitHub MCP server. TMP is a scratch dir removed on exit.
+# shellcheck shell=bash
+fail() { echo "$TOOL: $1; use the GitHub MCP server" >&2; exit 3; }
+on_exit() { local rc=$?; rm -rf "$TMP"; [ "$rc" -eq 0 ] || fail "GitHub request failed ($MODE)"; }
+gh_init() {
+  TOOL=$1
+  if { command -v gh && gh auth status; } >/dev/null 2>&1; then MODE=gh
+  elif [ -n "${CLAUDE_CODE_REMOTE:-}" ] && command -v curl >/dev/null; then MODE=rest
+  else fail "no authenticated gh or remote-session proxy"; fi
+  command -v jq >/dev/null || fail "jq not installed"
+  SLUG=$(git -C "$2" remote get-url origin) && SLUG=${SLUG#*github.com[:/]} && SLUG=${SLUG%.git}
+  TMP=$(mktemp -d)
+  trap on_exit EXIT
+}
+get() { if [ "$MODE" = gh ]; then gh api "$1"; else curl -fsS "https://api.github.com/$1"; fi; }
+post() { if [ "$MODE" = gh ]; then gh api -X POST "$1" --input -; else curl -fsS -X POST --data-binary @- "https://api.github.com/$1"; fi; }
diff --git a/.claude/skills/commit/SKILL.md b/.claude/skills/commit/SKILL.md
new file mode 100644
index 0000000..4b56757
--- /dev/null
+++ b/.claude/skills/commit/SKILL.md
@@ -0,0 +1,6 @@
+---
+name: commit
+description: Stage and commit using the project's commit message convention
+---
+
+In the worktree you're working on, from the workspace root (`git -C worktrees/<repo>/<branch> …`), stage the relevant changes (not unrelated or generated files) and commit using the commit message format in CLAUDE.md. Keep the description imperative and 2–8 words.
diff --git a/.claude/skills/consolidate-spikes/SKILL.md b/.claude/skills/consolidate-spikes/SKILL.md
new file mode 100644
index 0000000..057c827
--- /dev/null
+++ b/.claude/skills/consolidate-spikes/SKILL.md
@@ -0,0 +1,13 @@
+---
+name: consolidate-spikes
+description: Turn finished spikes into implementation tickets: an idea's spikes, once all are done, into dev work, under an epic when it comes from an idea or splits. Use when the user wants to wrap up, settle, or consolidate an idea or spike on an application-software repo (Argos, Nero).
+---
+
+Drafts and files by the `create-ticket` rules; load it and the project's `ticket-conventions` first. Takes an idea or a standalone spike.
+
+1. **Gather** each spike's findings comment, draft PR, and the PR's reviews; from an idea, its sub-issues too.
+2. **Check it's done.** Every spike is done by `create-ticket`'s Spikes rules (the lead's latest review on its draft PR, from repos/<owner>/<repo>/pulls/<pr>/reviews, is an approval). From an idea, that's every spike under it, and every approach is covered by a spike area. Otherwise list what's missing, offer spikes for uncovered approaches, and stop.
+3. **Choose:** per area (title prefix), propose the direction to build (one spike's, or a mix) with a one-line why, from the findings and the lead's review. The user confirms or changes each.
+4. **Plan** the dev work by `create-ticket`'s Dev work rules: one ticket unless the work is large enough to split into vertical slices, which may cross areas. Each ticket: What, the slice; Notes, links to the spikes and draft PRs it draws on, and the dropped directions with why; context transfer, the findings' facts.
+5. **Draft** them, and, from an idea or when split, one epic (From: the idea or spike) with the dev work as its sub-issues. Show all, with which slices run in parallel if split; file what the user OKs.
+6. **Close**, each with a one-line comment: the spikes as completed ("Consolidated into #<epic or dev work>"), their draft PRs unless a dev work ticket builds on that branch, and the idea as completed ("Settled in #<epic or dev work>").
diff --git a/.claude/skills/create-ticket/SKILL.md b/.claude/skills/create-ticket/SKILL.md
new file mode 100644
index 0000000..47b8960
--- /dev/null
+++ b/.claude/skills/create-ticket/SKILL.md
@@ -0,0 +1,66 @@
+---
+name: create-ticket
+description: Draft and file a GitHub issue (idea, spike, epic, or dev work) on an application-software repo (Argos, Nero) from the repo's issue templates, or rewrite an existing issue into them. Use whenever the user wants to create, file, write up, or log a ticket, issue, idea, spike, epic, bug, or task, including an out-of-scope idea that comes up mid-work.
+---
+
+# Create ticket
+
+These are the ticket conventions for every application-software repo. The repo's own `.github/ISSUE_TEMPLATE` holds only the fields (`gh api repos/<owner>/<repo>/contents/.github/ISSUE_TEMPLATE/<file> -q .content | base64 -d`); follow each field's description.
+
+First load the project's `ticket-conventions` skill (inherited from the project's `workspace-inherit/`) for its repo, area labels, vocabulary, and diagrams. If none is enabled, ask which repo.
+
+## Workflow
+
+idea → spikes → epic → dev work, or a standalone spike → dev work
+
+| Ticket | What it is | Issue type | Parent |
+|---|---|---|---|
+| Idea | What could be built and why. Its approaches are areas (open questions), each with directions worth trying. | none | none |
+| Spike | One direction to try in one area of an idea, or a small standalone improvement: what is tried and the hypothesis. Findings go in a comment and a draft PR (`report-spike`), not the ticket. | none | its idea, if any |
+| Epic | Work too large for one dev work ticket: the goal and whole-epic outcomes, not a walkthrough of each ticket. A new issue linking the idea or spike it came from in "From". | Feature | none |
+| Dev work | Any implementation work: testable requirements, Notes for gotchas and pointers to code. Large work is cut into vertical slices (see Dev work below). | Feature, Bug, or Task | its epic, if any |
+
+If unsure, a small, clear change is dev work, a small unknown is a spike, and a big unexplored thing is an idea. Ideas and spikes explore work, so they get no issue type; bug, feature, and task are issue types, never labels.
+
+## Writing
+
+How every ticket reads, on any project:
+
+- Short and plain. Write for someone new to the project: explain project-specific terms, and use the project's vocabulary (its `ticket-conventions` says where it lives; check the code for current names).
+- Outcomes, not implementation: say what changes and why, not how to build it. A rationale gives the reasoning, not a history of the problem.
+- No prescriptions on ideas and spikes. Ideas name open options to weigh, not a plan or a recommended pick; spikes state what to learn and leave the how to whoever picks it up.
+- Facts, not instructions: Notes and context transfer hold facts (where code lives, current behavior, constraints, links), not steps or a proposed solution. Context transfer (optional on spikes, epics, and dev work) starts with a short summary, then the raw context.
+- Unknowns stay open questions in Notes; don't guess.
+- Title: concise and imperative, no prefixes (except a spike's area).
+- Requirements: clear, broad checkboxes, each a testable outcome rather than an implementation step; 3-5, never more than 7. If it needs more, split the ticket.
+- Backticks: at most three inline uses per body; name files and identifiers in plain text. Diagram and context-transfer blocks don't count.
+- Size: keep ideas short; one small enough to just try is a spike.
+
+## Dev work
+
+- One ticket by default. Split only when the work is too large for one PR or parts could run in parallel.
+- When split, cut vertical slices: each goes end to end through every part it touches (e.g. backend through UI), not one layer, and works and is testable on its own. Cut for the most parallel work; mark a slice that must wait as blocked by the one it waits on (see File).
+
+## Spikes
+
+- One direction, not a set to choose between. If a spike reads "X or Y", it is two spikes.
+- Prefer an idea with a few spikes (often 2-4) under it; a spike can also stand alone, or with siblings, to explore an area.
+- Title it `<area>: <direction>`, with the area a short kebab-case name its siblings share (`graph-saving: Save a graph to a file and re-upload it`). An area may cover more than one of an idea's bullets. A lone small improvement needs no prefix.
+- Sibling spikes share the context transfer's summary and common facts; each adds only the facts particular to its direction.
+- An idea needn't get all its spikes at once: file an area's spikes when someone is ready to try them.
+- Done: its findings are posted, review feedback is addressed, and the lead's latest review on its draft PR is an approval (GitHub's Approve), including when the recommendation is to drop the direction. A done spike stays open until `consolidate-spikes` closes it.
+
+## Draft
+
+- Check the code first: the work may be done or already tracked.
+- One `### <field label>` per field in template order, following each field's description; omit empty optional fields.
+- Diagrams: required on epics, optional on dev work. The project's `ticket-conventions` says what they show.
+- Labels: the template's category (`idea`, `spike`, `epic`, `dev work`), one written-by (`by: human` if the user dictated it, `by: ai-assisted` if they gave the substance, `by: ai` if you wrote it, including rewrites), and at least one of the project's area labels.
+- Rewriting an old ticket: keep its intent and assignees; bring it up to these rules and update vocabulary, labels, issue type, and parent.
+- Folding one ticket into another: add it as a requirement on the target, then close it as not planned. Every close gets a one-line comment saying why.
+
+## File
+
+Check for open duplicates, then show the full draft (title, type if any, labels, parent, body) in the chat, not only in a file. File or edit only what the user OKs.
+
+Use the REST API (GraphQL may be blocked): POST repos/<owner>/<repo>/issues with title, body, labels, the issue type from the table, and the user as assignee (on a spike, whoever will run it; ask), then, if it has a parent, POST repos/<owner>/<repo>/issues/<parent>/sub_issues with the new issue's id. If it waits on another issue, POST repos/<owner>/<repo>/issues/<n>/dependencies/blocked_by with the blocking issue's id. Report the URL.
diff --git a/.claude/skills/implement/SKILL.md b/.claude/skills/implement/SKILL.md
new file mode 100644
index 0000000..1b70ad1
--- /dev/null
+++ b/.claude/skills/implement/SKILL.md
@@ -0,0 +1,13 @@
+---
+name: implement
+description: Implement an Argos ticket or task in its own worktree, test-first, ending in a commit. Use when the user asks to build, fix, or implement something in Argos.
+---
+
+1. **Worktree.** Get the ticket's branch (`{issue-number}-{kebab-case-title}`) with the `new-worktree` skill, based on `origin/develop`. Make every change in `worktrees/argos/<branch>/`, never in `worktrees/argos/develop/`, while staying at the workspace root: edit files by path, `git -C worktrees/argos/<branch> …` for git, and one-off subshells for the rest. Run `(cd worktrees/argos/<branch>/angular-client && npm ci)` before touching the client.
+2. **Understand.** Read the issue (`gh issue view <n> --comments`), the code involved, and `docs/CONTEXT.md` terms.
+3. **Build test-first**, one behavior at a time: a failing test, the least code to pass it, refactor while green. Test through public interfaces; mock only at system boundaries.
+4. **Check.**
+   - Frontend, in `(cd worktrees/argos/<branch>/angular-client && …)`: `npx ng test --include='src/**/thing.spec.ts' --watch=false` while iterating; at the end `npx ng test --watch=false` (bare `ng test` blocks), then `npx prettier --check "src/**/*.{ts,html,scss}" && npx ng lint`.
+   - Backend, in `(cd worktrees/argos/<branch>/scylla-server && …)`: `cargo build` and single tests while iterating; `cargo test` at the end.
+   - UI changes: verify in the running app with `run-local <branch>`.
+5. **Commit** with `/commit`. Don't push or open a PR unless asked; that's `/open-pr`.
diff --git a/.claude/skills/journal/SKILL.md b/.claude/skills/journal/SKILL.md
new file mode 100644
index 0000000..4917259
--- /dev/null
+++ b/.claude/skills/journal/SKILL.md
@@ -0,0 +1,22 @@
+---
+name: journal
+description: Park rough notes locally mid-task ("note to self", "remember to", "journal this"), and later export them to their permanent home (issue, spec, ADR, glossary, docs) through the skill that owns it. Use when the user wants to jot a thought without derailing, or to file parked notes.
+---
+
+Notes live in `.journal/` at the workspace root (git-excluded, outside worktrees so they survive removal). An **entry** is one file, a **category** a subfolder. The journal never pushes, files, or contacts GitHub itself.
+
+**Capture** (no git, no other skills):
+
+```
+bash scripts/capture.sh [-c <category>] ["note text"]
+```
+
+Omit `-c` for a loose entry, omit the text for an empty one to edit. Report the path it prints.
+
+**Export** (only when asked):
+
+1. Read the entries and propose a grouping: one entry → one output, a category → one merged output, or one entry split across several. Let the user adjust.
+2. For each output, pick the workspace skill whose description fits its permanent home, preferring an existing docs area. A new section always needs approval.
+3. Show the destination and reshaped text and wait for approval. Nothing lands silently.
+4. Delegate to that skill; it owns formatting, conventions, and any GitHub contact.
+5. Ask whether to delete the exported entry (default: keep).
diff --git a/.claude/skills/journal/scripts/capture.sh b/.claude/skills/journal/scripts/capture.sh
new file mode 100755
index 0000000..1e90d7b
--- /dev/null
+++ b/.claude/skills/journal/scripts/capture.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# capture.sh [-c <category>] [note text]: write a timestamped journal entry to
+# .journal/[<category>/] at the workspace root (adding /.journal/ to .git/info/exclude once) and print
+# its path. An empty entry is created when no text is given. Never touches git history, GitHub, or
+# other skills.
+set -euo pipefail
+usage="usage: capture.sh [-c <category>] [note text]"
+# shellcheck source=/dev/null
+. "${DELPHI_ROOT:?unset: start the session at the workspace root, on Delphi 0.2.0+ (pull its ws/ branch), or source <root>/.delphi/paths.sh}/.delphi/paths.sh"
+dir=$DELPHI_ROOT/.journal
+[ "${1:-}" = -c ] && dir=$dir/${2:?$usage} && shift 2
+exclude=$(git -C "$DELPHI_ROOT" rev-parse --path-format=absolute --git-path info/exclude 2>/dev/null || true)
+[ -z "$exclude" ] || grep -qxF /.journal/ "$exclude" 2>/dev/null || { mkdir -p "${exclude%/*}" && echo /.journal/ >>"$exclude"; }
+mkdir -p "$dir"
+file=$dir/$(date +%Y-%m-%d-%H%M%S).md
+{ echo "<!-- captured $(date -u +%Y-%m-%dT%H:%M:%SZ) -->"; [ $# -eq 0 ] || echo "$*"; } >"$file"
+echo "$file"
diff --git a/.claude/skills/new-worktree/SKILL.md b/.claude/skills/new-worktree/SKILL.md
new file mode 100644
index 0000000..9fd3ac7
--- /dev/null
+++ b/.claude/skills/new-worktree/SKILL.md
@@ -0,0 +1,15 @@
+---
+name: new-worktree
+description: Create or reuse a worktree for a branch of a code repo (worktrees/<repo>/<branch>). Use before any branch work, such as starting a ticket or reviewing or fixing a PR branch, unless the user says not to use worktrees.
+---
+
+Run from the workspace root:
+
+```
+bash .delphi/new-worktree.sh <repo> <branch> [<base>]
+```
+
+- An existing branch (local or on origin, e.g. a PR head) is checked out; anything else is created from `<base>` (default: the repo's default branch). Safe to re-run.
+- Stay at the workspace root and reach into the worktree by the printed path. Never switch branches in an existing worktree or work in the bare store `repos/<repo>`.
+- Keep `worktrees/<repo>/<default-branch>/` a clean reference: fetch and fast-forward only.
+- After the branch merges: `git -C repos/<repo> worktree remove ../../worktrees/<repo>/<branch>`.
diff --git a/.claude/skills/open-pr/SKILL.md b/.claude/skills/open-pr/SKILL.md
new file mode 100644
index 0000000..d2b9bf6
--- /dev/null
+++ b/.claude/skills/open-pr/SKILL.md
@@ -0,0 +1,21 @@
+---
+name: open-pr
+description: Run pre-PR checks, push the branch, and open a draft pull request on an application-software repo (Argos, Nero)
+---
+
+First load the project's `pr-conventions` skill (inherited from the project's `workspace-inherit/`) for its base branch, commit format, checks, labels, and screenshots.
+
+1. **Check:** `bash scripts/pr-checks.sh <repo> <branch> origin/<base> '<commit format>'` (clean tree, commit subjects match the project's format, merges cleanly into the base), then the project's own checks. Stop and fix on any FAIL.
+2. **Open:** push (`git -C worktrees/<repo>/<branch> push -u origin <branch>`), then run `(cd worktrees/<repo>/<branch> && gh pr create --draft --base <base> --head <branch> --title "<title>" --body-file /tmp/<branch>-pr-body.md --assignee @me)` with the project's labels (`--label`), and report the URL.
+3. **Spike:** the PR stays a draft; getting it merged isn't the goal. Once it's checked and working, run `report-spike`.
+
+## PR body
+
+Fill the worktree's `.github/pull_request_template.md` from the diff, following each section's comment, and write it to `/tmp/<branch>-pr-body.md`:
+
+- Title: concise and imperative, no ticket number.
+- The Changes section (not the whole body): about 50 words (1–3 sentences) on what landed and the key design choice. Describe the change, not the file list: don't enumerate components, classes or files the diff already shows. Name a specific one only when its behaviour changes in a way a reviewer must know.
+- Delete the template's comments and any optional or non-applicable sections, and check off the Checklist.
+- At most three backtick uses in the body.
+- End with `Closes #{ticket}` (the branch's leading number), or `Spike for #{ticket}` on a spike, which its PR never closes.
+- UI changes: put `_screenshot pending_` and remind the user to drag-drop the shots from the project's screenshot folder. Never commit screenshots.
diff --git a/.claude/skills/open-pr/scripts/pr-checks.sh b/.claude/skills/open-pr/scripts/pr-checks.sh
new file mode 100755
index 0000000..61f377f
--- /dev/null
+++ b/.claude/skills/open-pr/scripts/pr-checks.sh
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# pr-checks.sh <repo> <branch> [<base> [<format>]]: open-pr's shared pre-PR checks on
+# worktrees/<repo>/<branch>. Prints
+# one PASS/FAIL/SKIP line per check: clean tree, every commit subject since <base> (default
+# origin/develop, fetched first) matches <format> (an extended regex, default '^#[0-9]+ - '), and no
+# merge conflicts with <base>. Exits 1 if any check fails. The project's own checks (lint, format)
+# are in its pr-conventions skill.
+set -euo pipefail
+usage="usage: pr-checks.sh <repo> <branch> [<base> [<format>]]"
+repo=${1:?$usage} branch=${2:?$usage}
+# shellcheck source=/dev/null
+. "${DELPHI_ROOT:?unset: start the session at the workspace root, on Delphi 0.2.0+ (pull its ws/ branch), or source <root>/.delphi/paths.sh}/.delphi/paths.sh"
+cd "$DELPHI_WORKTREES/$repo/$branch"
+base=${3:-origin/develop} format=${4:-'^#[0-9]+ - '} fail=0
+res() { echo "$1 $2"; [ "$1" != FAIL ] || fail=1; }
+git fetch -q origin "${base#origin/}" 2>/dev/null || true
+
+if [ -z "$(git status --porcelain)" ]; then res PASS "clean tree"; else res FAIL "uncommitted changes"; fi
+bad=$(git log --format=%s "$base..HEAD" | grep -Ev "$format" || true)
+if [ -z "$bad" ]; then res PASS "commit format"; else res FAIL "commit format: $(echo "$bad" | paste -sd'|' -)"; fi
+if git merge-tree --write-tree HEAD "$base" >/dev/null 2>&1; then res PASS "merges cleanly into $base"
+elif [ $? -eq 1 ]; then res FAIL "conflicts with $base"; else res SKIP "conflict check (needs git 2.38+)"; fi
+exit "$fail"
diff --git a/.claude/skills/pr-conventions/SKILL.md b/.claude/skills/pr-conventions/SKILL.md
new file mode 100644
index 0000000..90cc657
--- /dev/null
+++ b/.claude/skills/pr-conventions/SKILL.md
@@ -0,0 +1,15 @@
+---
+name: pr-conventions
+description: Argos specifics for pull requests (base branch, commit format, checks, labels, screenshots, UI QA). Load before opening, updating, or reviewing an Argos PR, alongside open-pr, update-pr, and review.
+user-invocable: false
+---
+
+# Argos PR conventions
+
+The shared rules are in the `open-pr` skill; this adds only what is Argos's.
+
+- Base branch: `develop`. Commit format: `^#[0-9]+ - ` (the format in CLAUDE.md).
+- Checks: `bash scripts/lint.sh <branch>` (frontend prettier and ng lint, only if angular-client/ changed).
+- Labels: one written-by (`by: human` if the user wrote it, `by: ai-assisted` if they gave the substance, `by: ai` if you wrote it) and at least one area label (`frontend`, `backend`, `devops`); no category label.
+- Screenshots: `pictures/<branch>/` at the worktree root (git-ignored).
+- UI QA: get the branch running with `run-local <branch>`, then drive it with Playwright, using the `playwright-cdp` server if `curl -s localhost:9222/json/version` responds, otherwise `playwright`.
diff --git a/.claude/skills/pr-conventions/scripts/lint.sh b/.claude/skills/pr-conventions/scripts/lint.sh
new file mode 100644
index 0000000..2ed67ec
--- /dev/null
+++ b/.claude/skills/pr-conventions/scripts/lint.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# lint.sh <branch> [<base>]: Argos's pre-PR check for open-pr, on
+# worktrees/argos/<branch>. Prints one PASS/FAIL/SKIP line: frontend prettier + ng lint, only if
+# angular-client/ changed since <base> (default origin/develop). Exits 1 if it fails.
+set -euo pipefail
+usage="usage: lint.sh <branch> [<base>]"
+branch=${1:?$usage}
+# shellcheck source=/dev/null
+. "${DELPHI_ROOT:?unset: start the session at the workspace root, on Delphi 0.2.0+ (pull its ws/ branch), or source <root>/.delphi/paths.sh}/.delphi/paths.sh"
+cd "$DELPHI_WORKTREES/argos/$branch"
+base=${2:-origin/develop}
+if git diff --quiet "$base...HEAD" -- angular-client; then echo "SKIP frontend lint (no changes)"
+elif [ ! -d angular-client/node_modules ]; then echo "FAIL frontend lint: run npm ci in angular-client/" && exit 1
+elif (cd angular-client && npx prettier --check "src/**/*.{ts,html,scss}" >/dev/null && npx ng lint >/dev/null 2>&1)
+then echo "PASS frontend lint"; else echo "FAIL frontend lint (run prettier --check / ng lint to see why)" && exit 1; fi
diff --git a/.claude/skills/report-spike/SKILL.md b/.claude/skills/report-spike/SKILL.md
new file mode 100644
index 0000000..946b0bb
--- /dev/null
+++ b/.claude/skills/report-spike/SKILL.md
@@ -0,0 +1,22 @@
+---
+name: report-spike
+description: Post a spike's findings on its ticket, judged against its hypothesis, and ask the lead to review its draft PR. Use when a spike's direction has been tried on an application-software repo (Argos, Nero).
+---
+
+A spike runs like any ticket (branch, commits, a draft PR from `open-pr`); this reports it. Load the project's `pr-conventions` first.
+
+1. **Read** the spike (`gh issue view <n> --comments`), its draft PR, and the branch's diff against the base.
+2. **Draft** one findings comment, short and factual:
+
+   ```
+   ### Findings
+   **Hypothesis:** holds | partly holds | doesn't hold. One sentence why.
+   **Learned:** measurements, limits hit, surprises, with links to the draft PR's code.
+   **Recommendation:** adopt, adopt with changes, or drop, and why.
+   **Open questions:** what the spike didn't settle.
+   Draft PR: #<pr>
+   ```
+3. **Show** it and ask who the lead is; on OK, post it (`gh issue comment <n> --body-file /tmp/<branch>-findings.md`).
+4. **Request review:** `(cd worktrees/<repo>/<branch> && gh pr edit <branch> --add-reviewer <lead>)`, keeping the PR a draft, and remind the user to ping the lead on Slack.
+
+Address review feedback on the branch as on any PR (`address-pr-comments`), and edit the findings comment if it changes them. The spike is done when the lead approves the draft PR (`create-ticket`'s Spikes rules); it stays open until `consolidate-spikes` closes it.
diff --git a/.claude/skills/run-local/SKILL.md b/.claude/skills/run-local/SKILL.md
new file mode 100644
index 0000000..d99b18a
--- /dev/null
+++ b/.claude/skills/run-local/SKILL.md
@@ -0,0 +1,14 @@
+---
+name: run-local
+description: Bring up the local Argos environment for running or testing — Docker backend (right profile for what changed) + an Angular client per worktree, each on its own free port. Use whenever you need to actually run the app locally, for a PR, a ticket's branch, or develop.
+---
+
+Run the branches the user is asking about: a PR or ticket means its branch (make its worktree with `new-worktree` first), and `develop` only when they want current `develop` (fast-forward `worktrees/argos/develop/` first):
+
+```
+bash scripts/run-local.sh <branch>...
+```
+
+It starts the backend if it's down (`client-dev`, or `scylla-dev` plus `cargo run` when a target changes `scylla-server/`), and serves each target's client on the next free port. With no branches it reports what's running.
+
+Report each branch's client URL and the backend. A failed compile or a stale-backend warning is a finding: show it to the user. Stop a client with `kill <pid>` from its line.
diff --git a/.claude/skills/run-local/scripts/run-local.sh b/.claude/skills/run-local/scripts/run-local.sh
new file mode 100755
index 0000000..f598657
--- /dev/null
+++ b/.claude/skills/run-local/scripts/run-local.sh
@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# run-local.sh [<branch>...]: bring up the local Argos stack for those branches'
+# worktrees (worktrees/argos/<branch>, made beforehand with new-worktree) and print one line per
+# piece. The backend (first listener on 8000-8090, step 10) is started if down:
+# ./argos.sh client-dev when no target changes scylla-server/, else scylla-dev plus `cargo run` in the
+# one worktree that does. Each target's client is then served by serve.sh on its own port. With no
+# branches, reports what is running.
+set -euo pipefail
+here=$(cd "$(dirname "$0")" && pwd)
+# shellcheck source=/dev/null
+. "${DELPHI_ROOT:?unset: start the session at the workspace root, on Delphi 0.2.0+ (pull its ws/ branch), or source <root>/.delphi/paths.sh}/.delphi/paths.sh"
+state=${TMPDIR:-/tmp}; state=${state%/}/argos-run-local
+up() { (exec 3<>"/dev/tcp/127.0.0.1/$1") 2>/dev/null || (exec 3<>"/dev/tcp/::1/$1") 2>/dev/null; } # ng serve binds ::1
+backend() { for p in $(seq 8000 10 8090); do up "$p" && echo "http://localhost:$p" && return; done; echo none; }
+scylla() {
+  if docker ps --filter name=scylla-server --format '{{.Names}}' 2>/dev/null | grep -q .; then echo docker
+  elif [ "$(backend)" != none ]; then echo local
+  else echo none; fi
+}
+
+if [ $# = 0 ]; then
+  clients=
+  for p in $(seq 4200 4210); do up "$p" && clients="$clients http://localhost:$p"; done
+  echo "backend=$(backend) scylla=$(scylla) clients=${clients# }"
+  exit 0
+fi
+
+wts=() rust=()
+for b in "$@"; do
+  wt=$DELPHI_WORKTREES/argos/$b
+  [ -f "$wt/argos.sh" ] && [ -d "$wt/angular-client" ] ||
+    { echo "run-local: no Argos worktree for '$b' at $wt (make it with new-worktree)" >&2 && exit 1; }
+  wts+=("$wt")
+done
+git -C "${wts[0]}" fetch -q origin # the worktrees share one store
+for wt in "${wts[@]}"; do
+  if ! git -C "$wt" diff --quiet origin/develop... -- scylla-server || ! git -C "$wt" diff --quiet HEAD -- scylla-server; then
+    rust+=("$wt")
+  fi
+done
+[ ${#rust[@]} -le 1 ] || { echo "run-local: several targets change scylla-server/; run them one at a time" >&2 && exit 1; }
+
+if [ "$(backend)" = none ]; then
+  mkdir -p "$state"
+  if [ ${#rust[@]} = 0 ]; then
+    (cd "${wts[0]}" && ./argos.sh client-dev up -d) >"$state/compose.log" 2>&1 ||
+      { echo "run-local: ./argos.sh client-dev up failed:" >&2 && tail -20 "$state/compose.log" >&2 && exit 1; }
+  else
+    (cd "${rust[0]}" && ./argos.sh scylla-dev up -d) >"$state/compose.log" 2>&1 ||
+      { echo "run-local: ./argos.sh scylla-dev up failed:" >&2 && tail -20 "$state/compose.log" >&2 && exit 1; }
+    (cd "${rust[0]}/scylla-server" &&
+      DATABASE_URL=${DATABASE_URL:-postgresql://postgres:password@127.0.0.1:${ODYSSEY_DB_PORT:-5432}/postgres} \
+        nohup cargo run >"$state/scylla.log" 2>&1 &)
+    echo "run-local: cargo run started for $(basename "${rust[0]}"); log $state/scylla.log"
+  fi
+  for _ in $(seq 600); do [ "$(backend)" != none ] && break; sleep 1; done
+  [ "$(backend)" != none ] || { echo "run-local: backend not up after 600s; see $state/" >&2 && exit 1; }
+elif [ ${#rust[@]} = 1 ] && [ "$(scylla)" = docker ]; then
+  echo "run-local: warning: backend is the scylla-server image but $(basename "${rust[0]}") changes scylla-server/;" \
+    "stop it (./argos.sh client-dev down) and re-run to test that branch's backend" >&2
+fi
+echo "backend=$(backend) scylla=$(scylla)"
+
+status=0
+for wt in "${wts[@]}"; do bash "$here/serve.sh" "$wt" || status=1; done
+exit $status
diff --git a/.claude/skills/run-local/scripts/serve.sh b/.claude/skills/run-local/scripts/serve.sh
new file mode 100755
index 0000000..cf98f99
--- /dev/null
+++ b/.claude/skills/run-local/scripts/serve.sh
@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+# serve.sh <argos-worktree>: serve that worktree's Angular client with `ng serve` on the first free
+# port in 4200-4210, in the background, and print `<branch> client=<url> pid=<pid> log=<file>` once
+# it has compiled. Re-running for a worktree that is still being served prints its existing client.
+# Runs `npm ci` first if node_modules lacks ng (missing or half-installed). Exits 1, with the log's
+# tail, if the build fails.
+set -euo pipefail
+wt=$(cd "${1:?usage: serve.sh <argos-worktree>}" && pwd)
+branch=$(git -C "$wt" rev-parse --abbrev-ref HEAD)
+state=${TMPDIR:-/tmp}; state=${state%/}/argos-run-local
+mkdir -p "$state"
+key=$state/$(printf %s "$wt" | tr -c 'A-Za-z0-9' _)
+log=$key.log
+up() { (exec 3<>"/dev/tcp/127.0.0.1/$1") 2>/dev/null || (exec 3<>"/dev/tcp/::1/$1") 2>/dev/null; } # ng serve binds ::1
+
+if [ -f "$key.pid" ] && kill -0 "$(cat "$key.pid")" 2>/dev/null && up "$(cat "$key.port")"; then
+  echo "$branch client=http://localhost:$(cat "$key.port") pid=$(cat "$key.pid") log=$log (already running)"
+  exit 0
+fi
+
+port=
+for p in $(seq 4200 4210); do up "$p" || { port=$p && break; }; done
+[ -n "$port" ] || { echo "serve: no free port in 4200-4210" >&2 && exit 1; }
+
+cd "$wt/angular-client"
+[ -x node_modules/.bin/ng ] || npm ci --no-audit --no-fund >"$log" 2>&1 ||
+  { echo "serve: npm ci failed in $wt/angular-client:" >&2 && tail -20 "$log" >&2 && exit 1; }
+nohup npx ng serve --port "$port" >"$log" 2>&1 &
+pid=$!
+echo "$pid" >"$key.pid" && echo "$port" >"$key.port"
+
+for _ in $(seq 180); do
+  kill -0 "$pid" 2>/dev/null || { echo "serve: ng serve exited for $branch:" >&2 && tail -20 "$log" >&2 && exit 1; }
+  if grep -q 'bundle generation failed\|\[ERROR\]' "$log"; then
+    echo "serve: $branch failed to compile (still serving on $port, pid $pid):" >&2 && tail -30 "$log" >&2 && exit 1
+  fi
+  if up "$port" && grep -q 'bundle generation complete\|Compiled successfully' "$log"; then
+    echo "$branch client=http://localhost:$port pid=$pid log=$log"
+    exit 0
+  fi
+  sleep 1
+done
+echo "serve: $branch not up after 180s (pid $pid); see $log" >&2 && exit 1
diff --git a/.claude/skills/setup-workspace/SKILL.md b/.claude/skills/setup-workspace/SKILL.md
new file mode 100644
index 0000000..6e73fb3
--- /dev/null
+++ b/.claude/skills/setup-workspace/SKILL.md
@@ -0,0 +1,18 @@
+---
+name: setup-workspace
+description: Change what this workspace checks out and re-run its setup. workspace.yml lists code repos (repos:), read-only dependency sources (references-git:), and read-only copies of other Delphi workspaces or main (workspaces:). Use when the user wants to read or compare another workspace's or main's instructions, skills, or docs (link it), add or remove a repo or dependency reference, or run setup after cloning or pulling.
+---
+
+`workspace.yml` at the workspace root lists what `.delphi/setup.sh` checks out, all git-ignored: code repos (`repos:`), dependency sources (`references-git:`), and other Delphi workspaces or main (`workspaces:`, entries `- ws/<name>` or `- main`; a workspace's name is its place in the tree, like `software/application-software/argos/argos-dev`). The comment on each section gives its entry format and where it lands; read it, then edit the file.
+
+Run from the workspace root after any change, and to refresh references and workspace copies to their latest:
+
+```
+bash .delphi/setup.sh
+```
+
+- The copies under `linked/` are for reading: never edit, branch, or push them. To change one of those workspaces or main, switch to it (`switch-workspace` skill).
+- This workspace's project folder (shared context, `AUTHORING.md`, `workspace-defaults/`) is `linked/main/` plus this workspace's name without its last part: for `software/application-software/argos/argos-dev`, `linked/main/software/application-software/argos/`. List workspaces: `git branch -r --list 'origin/ws/*'`.
+- `workspace.yml` is shared: change it on a branch and open a PR into `ws/<this-name>` (the `name:` in `workspace.yml`). For a one-off look, add the entry, run setup, then `git restore workspace.yml`.
+- Setup never deletes what you'd lose. A removed entry's `linked/<branch>/`, `references/<name>/`, or repo store and worktrees stay until you delete them (ask first).
+- When Delphi releases a version that needs cleanup in clones, setup runs its migration first (`.delphi/migrations/`), once per workspace. A migration removes only what nothing is lost from, and otherwise stops setup with what to do: tell the user, do it with their go-ahead, and re-run.
diff --git a/.claude/skills/switch-workspace/SKILL.md b/.claude/skills/switch-workspace/SKILL.md
new file mode 100644
index 0000000..4ca2ab9
--- /dev/null
+++ b/.claude/skills/switch-workspace/SKILL.md
@@ -0,0 +1,21 @@
+---
+name: switch-workspace
+description: Switch this clone to another Delphi workspace, or to Delphi's main, to work in it. Use when the user wants to check out, switch to, open, or work in another workspace or project, or to change another workspace's or main's files.
+---
+
+Run from the workspace root:
+
+```
+bash .delphi/switch.sh <name>        # ws/<name>: its place in the tree, e.g. software/application-software/argos/argos-dev
+bash .delphi/switch.sh argos-dev     # its last part alone, if only one workspace ends in it
+bash .delphi/switch.sh main          # Delphi's main: project folders, templates, CI
+```
+
+- The user can also switch from the `/ws-delphi` pane (the `delphi` plugin's mod), which shows them as cards (`bash .delphi/switch.sh --list`): press one, then Switch workspace; `/ws-delphi <name>` switches straight away, and `/ws-delphi --web` opens the same cards in a browser tab.
+- List workspaces: `git branch -r --list 'origin/ws/*'`. A workspace's name is its folder path on main without `workspaces/`.
+- It refuses while tracked files have changes: commit them on a branch (and PR them) first. Then it fetches, switches, fast-forwards, and runs the new workspace's `.delphi/setup.sh`.
+- The post-checkout hook parks this workspace's `repos/`, `worktrees/`, `references/` and `linked/` in `.delphi/parked/<name>/` (git-ignored; `<name>` as in its `workspace.yml`) and brings the other's back at the same paths, so worktrees and the work in them return as they were. Switch back the same way. Never run `git clean -X` or `git stash --all` at the workspace root: they take ignored files, parked work included.
+- Before switching, stop anything running from `worktrees/` (dev servers, Docker builds): its folder moves.
+- No restart needed: skills under `.claude/skills/` reload on their own, and the `delphi` mod sends the new workspace's `CLAUDE.md` with the next prompt. Without the mod installed, this session keeps the old `CLAUDE.md`: tell the user to restart Claude Code in the same folder before starting work in the new workspace.
+- To change the workspace you switched to: `git switch -c <branch>`, commit, push, and open a PR into `ws/<name>` (or `main`).
+- To only read another workspace or main without leaving this one, list it under `workspaces:` instead (`setup-workspace` skill).
diff --git a/.claude/skills/ticket-conventions/SKILL.md b/.claude/skills/ticket-conventions/SKILL.md
new file mode 100644
index 0000000..b516657
--- /dev/null
+++ b/.claude/skills/ticket-conventions/SKILL.md
@@ -0,0 +1,15 @@
+---
+name: ticket-conventions
+description: Argos specifics for tickets (repo, area labels, vocabulary, diagrams). Load before drafting or filing an Argos issue, alongside create-ticket.
+user-invocable: false
+---
+
+# Argos ticket conventions
+
+The shared rules are in the `create-ticket` skill; this adds only what is Argos's.
+
+- Repo: Northeastern-Electric-Racing/Argos (base branch `develop`).
+- Area labels: `frontend`, `backend`, `devops` (any combination).
+- Vocabulary: use the workspace glossary's terms (`docs/CONTEXT.md`), and check the code for current names, which may have moved past it (e.g. Zenoh key expressions, not MQTT topics).
+- Title example: "Add pagination to the run list".
+- Diagrams: Mermaid where it fits. Show the change across the parts it touches (car, Siren, scylla-server, angular-client), before and after.
diff --git a/.claude/skills/update-pr/SKILL.md b/.claude/skills/update-pr/SKILL.md
new file mode 100644
index 0000000..3664f3a
--- /dev/null
+++ b/.claude/skills/update-pr/SKILL.md
@@ -0,0 +1,6 @@
+---
+name: update-pr
+description: Update a branch's PR description to reflect the latest changes
+---
+
+Load the project's `pr-conventions` skill, then rewrite the branch's PR body (`(cd worktrees/<repo>/<branch> && gh pr view)`) to match `git -C worktrees/<repo>/<branch> diff origin/<base>...HEAD`, following the PR body rules in the `open-pr` skill. Keep human-written text that's still accurate, `user-attachments` screenshots, and `Closes`/`Fixes` refs. Write it to `/tmp/<branch>-pr-body.md`, apply it with `gh pr edit <branch> --body-file` from the worktree, and add any of the project's labels that are missing with `--add-label`.
diff --git a/.claude/skills/verify-graph/SKILL.md b/.claude/skills/verify-graph/SKILL.md
new file mode 100644
index 0000000..cd04379
--- /dev/null
+++ b/.claude/skills/verify-graph/SKILL.md
@@ -0,0 +1,21 @@
+---
+name: verify-graph
+description: Playwright MCP verification of the graph page — modes, controls, topic selection, and data rendering. Use after any change to graph-page components, graph rendering, data flow, or mode switching logic.
+user-invocable: true
+---
+
+Get the ticket's branch running with `run-local <branch>`; that branch's client URL is `BASE_URL`. Historical runs with data must exist. Screenshots go to `pictures/<branch>/verify-graph/NN-<name>.png` (gitignored).
+
+Per check: `browser_navigate` → `browser_snapshot` (assert) → `browser_click` or `browser_run_code` → `browser_take_screenshot`. Two clicks need `browser_run_code` with a body from `helpers.js`: **selectRun** ("Select this Run" sits under a PrimeNG overlay) and **selectTopic** (a tree click on a leaf navigates away). Run the groups in order; stop and fix at the first failure.
+
+| # | Do | Assert |
+|---|---|---|
+| 1 | Open `{BASE_URL}/graph` | Header "Real Time"; Pause, Time Range, Select Run, Clear Graph; "X (sec):", Y Min/Max, "Select Range"; no Realtime button |
+| 2 | Expand BMS › Pack, selectTopic "Voltage", wait 3s | URL has `?topics=BMS/Pack/Voltage`; a series is drawn |
+| 3 | Pause↔Play; Time Range↔Point Range; Tog Sidebar twice | Labels flip ("X (points):" in point range); sidebar hides, then returns |
+| 4 | Select Run, then selectRun, wait 3s | Header "Run #N"; Realtime shown; no Pause or Time Range; Y Min/Max remain; x-axis spans more than 30s |
+| 5 | Realtime; open Select Range, pick "5 minutes" | 7 options (1, 2, 5, 10, 15, 30 min, 1 hour); header "Hist Range"; Realtime shown, no Pause; x-axis about 5 min |
+| 6 | Cycle Realtime → Run → Realtime → "1 minute" → Realtime | Headers match each mode; no console errors (`browser_console_messages`) |
+| 7 | In real time, wait 10s | x-axis about 30s, not the whole session (historical auto-fit doesn't leak) |
+
+Report a checklist (one line per group, `[x]` or `[ ]` with the failure) and the screenshot folder.
diff --git a/.claude/skills/verify-graph/helpers.js b/.claude/skills/verify-graph/helpers.js
new file mode 100644
index 0000000..09a6304
--- /dev/null
+++ b/.claude/skills/verify-graph/helpers.js
@@ -0,0 +1,24 @@
+// Bodies for Playwright MCP `browser_run_code` in the verify-graph skill. Paste one function as-is.
+
+// selectRun: the run carousel's "Select this Run" button sits under a PrimeNG overlay, so click it
+// with a synthetic event instead of browser_click.
+async (page) => {
+  await page.waitForTimeout(1500);
+  await page.evaluate(() => {
+    const btn = Array.from(document.querySelectorAll('button'))
+      .find(b => b.textContent?.includes('Select this Run'));
+    if (btn) btn.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+  });
+  await page.waitForTimeout(2000);
+}
+
+// selectTopic: clicking a leaf in the tree navigates away, so click its label instead.
+// Change 'Voltage' to the leaf you want.
+async (page) => {
+  await page.evaluate((topicName) => {
+    const p = Array.from(document.querySelectorAll('p'))
+      .find(el => el.textContent?.trim() === topicName);
+    if (p) p.click();
+  }, 'Voltage');
+  await page.waitForTimeout(3000);
+}
diff --git a/.claude/skills/verify-telemetry/SKILL.md b/.claude/skills/verify-telemetry/SKILL.md
new file mode 100644
index 0000000..006fff6
--- /dev/null
+++ b/.claude/skills/verify-telemetry/SKILL.md
@@ -0,0 +1,16 @@
+---
+name: verify-telemetry
+description: Verification checklist for changes to MQTT-displayed telemetry values in the Angular frontend. Use whenever modifying, adding, or debugging a value that flows from the car through MQTT to the UI — including display formatting, new subscriptions, missing data, or incorrect readings.
+---
+
+Work from the workspace root against the ticket's worktree, `worktrees/argos/<branch>/` (via `new-worktree`). Stop and fix at the first failing step.
+
+1. **Trace the subscription** in that worktree, from the component: its property is updated by a `this.storage.get(topics.someTopicFn())` subscription, the function in `angular-client/src/utils/topic.utils.ts` returns the right topic, and the value is parsed right for its type (`parseInt` vs `parseFloat`). A missing subscription is the bug.
+2. **Check the topic end to end:**
+
+   ```bash
+   bash scripts/check-topic.sh <TOPIC>
+   ```
+
+   It prints the CAN definition (unit, value points; exit 1 if the topic isn't defined), refreshes the Calypso image (if it changed, restart with `(cd worktrees/argos/<branch> && ./argos.sh client-dev down)` then `run-local <branch>`), and shows the topic's last scylla-server log lines. Confirm the unit and value index match the UI; no log lines means it isn't being published.
+3. **See it live:** bring the app up with `run-local <branch>`, open the page with Playwright, wait for data, and screenshot to `pictures/<branch>/<name>.png`. Check value, formatting, and layout.
diff --git a/.claude/skills/verify-telemetry/scripts/check-topic.sh b/.claude/skills/verify-telemetry/scripts/check-topic.sh
new file mode 100755
index 0000000..c9a9c0a
--- /dev/null
+++ b/.claude/skills/verify-telemetry/scripts/check-topic.sh
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# check-topic.sh <topic>: check one MQTT topic end to end for verify-telemetry. Prints
+# its CAN definition (file, message id, unit, value points) from worktrees/odyssey-definitions/main,
+# whether the Calypso simulator image is current and running,
+# and the topic's last scylla-server log lines. Exits 1 if the topic isn't defined. Needs jq; the
+# docker checks are skipped without docker.
+set -euo pipefail
+usage="usage: check-topic.sh <topic>"
+topic=${1:?$usage}
+# shellcheck source=/dev/null
+. "${DELPHI_ROOT:?unset: start the session at the workspace root, on Delphi 0.2.0+ (pull its ws/ branch), or source <root>/.delphi/paths.sh}/.delphi/paths.sh"
+defs=$DELPHI_WORKTREES/odyssey-definitions/main/can-messages
+[ -d "$defs" ] || { echo "no CAN definitions at $defs; add odyssey-definitions under repos: and run .delphi/setup.sh" >&2; exit 2; }
+
+echo "== CAN definition"
+jq -ce --arg t "$topic" 'input_filename as $f | .[] | . as $m | .fields[]? | select(.name == $t) |
+  {file: ($f | split("/")[-1]), id: $m.id, desc: $m.desc, unit, points: [.values[] | $m.points[. - 1].name]}' \
+  "$defs"/*.json || { echo "not found: $topic"; exit 1; }
+
+command -v docker >/dev/null || { echo "== docker not installed; skipping Calypso and logs"; exit 0; }
+echo "== Calypso"
+if docker pull -q ghcr.io/northeastern-electric-racing/calypso:Develop >/dev/null 2>&1; then
+  echo "image pulled (restart the stack if it changed)"; else echo "pull failed"; fi
+docker ps --filter name=calypso --format '{{.Names}} {{.Status}}' 2>/dev/null | grep . || echo "calypso not running"
+echo "== scylla-server log"
+c=$(docker ps --filter name=scylla-server --format '{{.Names}}' 2>/dev/null | head -1) # compose names it <project>-scylla-server-1
+if [ -z "$c" ]; then echo "scylla-server not running in docker (local cargo run? check its log)"
+else docker logs "$c" 2>&1 | grep -F "$topic" | tail -5 | grep . || echo "no log lines for $topic (not published?)"; fi

From a399b6b94f900d6ed082be5295a2429245197639 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 18 Oct 2026 16:08:48 +0000
Subject: [PATCH 03/19] delphi: sync inherited files from main

---
 .claude/skills/run-local/SKILL.md             |  2 +-
 .claude/skills/run-local/scripts/serve.sh     | 11 ++-
 .claude/skills/verify-graph/SKILL.md          | 27 +++---
 .claude/skills/verify-graph/helpers.js        | 24 ------
 .claude/skills/verify-graph/scripts/check.js  | 82 +++++++++++++++++++
 .claude/skills/verify-graph/scripts/check.sh  | 14 ++++
 .claude/skills/verify-graph/scripts/open.sh   | 14 ++++
 .claude/skills/verify-graph/scripts/seed.sh   | 31 +++++++
 .../skills/verify-graph/scripts/select-run.sh | 18 ++++
 9 files changed, 184 insertions(+), 39 deletions(-)
 delete mode 100644 .claude/skills/verify-graph/helpers.js
 create mode 100644 .claude/skills/verify-graph/scripts/check.js
 create mode 100755 .claude/skills/verify-graph/scripts/check.sh
 create mode 100755 .claude/skills/verify-graph/scripts/open.sh
 create mode 100755 .claude/skills/verify-graph/scripts/seed.sh
 create mode 100755 .claude/skills/verify-graph/scripts/select-run.sh

diff --git a/.claude/skills/run-local/SKILL.md b/.claude/skills/run-local/SKILL.md
index d99b18a..8618099 100644
--- a/.claude/skills/run-local/SKILL.md
+++ b/.claude/skills/run-local/SKILL.md
@@ -9,6 +9,6 @@ Run the branches the user is asking about: a PR or ticket means its branch (make
 bash scripts/run-local.sh <branch>...
 ```
 
-It starts the backend if it's down (`client-dev`, or `scylla-dev` plus `cargo run` when a target changes `scylla-server/`), and serves each target's client on the next free port. With no branches it reports what's running.
+It starts the backend if it's down (`client-dev`, or `scylla-dev` plus `cargo run` when a target changes `scylla-server/`), and serves each target's client on the next free port; parallel runs (one per session or agent) each get their own. With no branches it reports what's running.
 
 Report each branch's client URL and the backend. A failed compile or a stale-backend warning is a finding: show it to the user. Stop a client with `kill <pid>` from its line.
diff --git a/.claude/skills/run-local/scripts/serve.sh b/.claude/skills/run-local/scripts/serve.sh
index cf98f99..99d5095 100755
--- a/.claude/skills/run-local/scripts/serve.sh
+++ b/.claude/skills/run-local/scripts/serve.sh
@@ -18,9 +18,18 @@ if [ -f "$key.pid" ] && kill -0 "$(cat "$key.pid")" 2>/dev/null && up "$(cat "$k
   exit 0
 fi
 
+# Claim the port under a lock, or parallel calls all pick the same one while ng serve starts. A port is
+# taken once a client listens on it or a live serve.sh has claimed it. mkdir is the lock (no flock on
+# macOS); it is held only for the claim, so nothing started below can keep it.
+lock=$state/port.lock
+n=0; until mkdir "$lock" 2>/dev/null; do n=$((n + 1)); [ $n -lt 100 ] || rm -rf "$lock"; sleep 0.1; done # stale after 10s
+trap 'rmdir "$lock" 2>/dev/null || true' EXIT
+claimed() { for f in "$state"/*.port; do [ -f "$f" ] && [ "$(cat "$f")" = "$1" ] && kill -0 "$(cat "${f%.port}.pid")" 2>/dev/null && return; done; return 1; }
 port=
-for p in $(seq 4200 4210); do up "$p" || { port=$p && break; }; done
+for p in $(seq 4200 4210); do up "$p" || claimed "$p" || { port=$p && break; }; done
 [ -n "$port" ] || { echo "serve: no free port in 4200-4210" >&2 && exit 1; }
+echo $$ >"$key.pid" && echo "$port" >"$key.port" # claimed by this script until ng serve's pid replaces it
+rmdir "$lock" && trap - EXIT
 
 cd "$wt/angular-client"
 [ -x node_modules/.bin/ng ] || npm ci --no-audit --no-fund >"$log" 2>&1 ||
diff --git a/.claude/skills/verify-graph/SKILL.md b/.claude/skills/verify-graph/SKILL.md
index cd04379..64167c9 100644
--- a/.claude/skills/verify-graph/SKILL.md
+++ b/.claude/skills/verify-graph/SKILL.md
@@ -1,21 +1,22 @@
 ---
 name: verify-graph
-description: Playwright MCP verification of the graph page — modes, controls, topic selection, and data rendering. Use after any change to graph-page components, graph rendering, data flow, or mode switching logic.
+description: Playwright CLI verification of the graph page — modes, controls, topic selection, and data rendering. Use after any change to graph-page components, graph rendering, data flow, or mode switching logic.
 user-invocable: true
 ---
 
-Get the ticket's branch running with `run-local <branch>`; that branch's client URL is `BASE_URL`. Historical runs with data must exist. Screenshots go to `pictures/<branch>/verify-graph/NN-<name>.png` (gitignored).
+Get the branch's client running with `run-local <branch>`; its URL is `BASE_URL`. Then run the base checks:
 
-Per check: `browser_navigate` → `browser_snapshot` (assert) → `browser_click` or `browser_run_code` → `browser_take_screenshot`. Two clicks need `browser_run_code` with a body from `helpers.js`: **selectRun** ("Select this Run" sits under a PrimeNG overlay) and **selectTopic** (a tree click on a leaf navigates away). Run the groups in order; stop and fix at the first failure.
+```
+bash scripts/check.sh <branch> "$BASE_URL"
+```
 
-| # | Do | Assert |
-|---|---|---|
-| 1 | Open `{BASE_URL}/graph` | Header "Real Time"; Pause, Time Range, Select Run, Clear Graph; "X (sec):", Y Min/Max, "Select Range"; no Realtime button |
-| 2 | Expand BMS › Pack, selectTopic "Voltage", wait 3s | URL has `?topics=BMS/Pack/Voltage`; a series is drawn |
-| 3 | Pause↔Play; Time Range↔Point Range; Tog Sidebar twice | Labels flip ("X (points):" in point range); sidebar hides, then returns |
-| 4 | Select Run, then selectRun, wait 3s | Header "Run #N"; Realtime shown; no Pause or Time Range; Y Min/Max remain; x-axis spans more than 30s |
-| 5 | Realtime; open Select Range, pick "5 minutes" | 7 options (1, 2, 5, 10, 15, 30 min, 1 hour); header "Hist Range"; Realtime shown, no Pause; x-axis about 5 min |
-| 6 | Cycle Realtime → Run → Realtime → "1 minute" → Realtime | Headers match each mode; no console errors (`browser_console_messages`) |
-| 7 | In real time, wait 10s | x-axis about 30s, not the whole session (historical auto-fit doesn't leak) |
+It seeds a 50-hour run spanning two midnights (once, shared by parallel checks), opens a `playwright-cli` session named after the branch (`scripts/open.sh`: output to `pictures/<branch>/`, config to `.playwright-cli/<branch>/`), and runs `scripts/check.js`. That covers: page loads in real time, a topic from the tree draws live, the seeded run, historical Quick Select, back to real time, and no console errors beyond develop's NG0100. It prints `[x]`/`[ ]` per check and exits 1 on a failure. Each `look:` line names a screenshot and what it should show: open it and judge it, since only a picture shows whether a chart is right.
 
-Report a checklist (one line per group, `[x]` or `[ ]` with the failure) and the screenshot folder.
+Go further where the diff points, by hand in the same session (`P="playwright-cli -s=<branch>"`): controls the diff touches (Pause↔Play, Time Range↔Point Range, Tog Sidebar, Tog Mult Yaxis, Y Min/Max, Custom range, Clear Graph), zoom, pan and hover, several topics, or mode switching for console errors. Reproduce a failed check the same way before fixing it; `check.js` has its steps.
+
+- Act: `$P click "button:has-text('Pause')"`, `role=combobox[name='Quick Select']`, `role=option[name='5 minutes']`, or a ref from `$P snapshot`.
+- Assert: `$P find "<text>"`, `$P snapshot`, `$P console error`; longer Playwright code with `$P run-code "async (page) => {…}"`, or `--filename` for a file kept in `.playwright-cli/<branch>/`.
+- The seeded run: click Select Run, then `bash scripts/select-run.sh <branch> $(bash scripts/seed.sh)`.
+- Screenshots: `$P screenshot --filename=pictures/<branch>/verify-graph/NN-<name>.png` (gitignored).
+
+When a hand check keeps coming back, add it to `check.js`. Report `check.sh`'s lines plus one line per hand check, and the screenshot folder. `$P close` at the end.
diff --git a/.claude/skills/verify-graph/helpers.js b/.claude/skills/verify-graph/helpers.js
deleted file mode 100644
index 09a6304..0000000
--- a/.claude/skills/verify-graph/helpers.js
+++ /dev/null
@@ -1,24 +0,0 @@
-// Bodies for Playwright MCP `browser_run_code` in the verify-graph skill. Paste one function as-is.
-
-// selectRun: the run carousel's "Select this Run" button sits under a PrimeNG overlay, so click it
-// with a synthetic event instead of browser_click.
-async (page) => {
-  await page.waitForTimeout(1500);
-  await page.evaluate(() => {
-    const btn = Array.from(document.querySelectorAll('button'))
-      .find(b => b.textContent?.includes('Select this Run'));
-    if (btn) btn.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
-  });
-  await page.waitForTimeout(2000);
-}
-
-// selectTopic: clicking a leaf in the tree navigates away, so click its label instead.
-// Change 'Voltage' to the leaf you want.
-async (page) => {
-  await page.evaluate((topicName) => {
-    const p = Array.from(document.querySelectorAll('p'))
-      .find(el => el.textContent?.trim() === topicName);
-    if (p) p.click();
-  }, 'Voltage');
-  await page.waitForTimeout(3000);
-}
diff --git a/.claude/skills/verify-graph/scripts/check.js b/.claude/skills/verify-graph/scripts/check.js
new file mode 100644
index 0000000..bd1e8b0
--- /dev/null
+++ b/.claude/skills/verify-graph/scripts/check.js
@@ -0,0 +1,82 @@
+// The base verify-graph checks, for check.sh to run with `playwright-cli run-code` (it fills in __URL__,
+// __RUN__ and __OUT__). Each check asserts what the DOM can show; what only a picture can show (a series
+// drawn, the x-axis span) is a screenshot with a `look:` line for the agent to judge.
+async (page) => {
+  const URL = '__URL__', RUN = __RUN__, OUT = '__OUT__';
+  const lines = [], errors = [];
+  page.on('console', (m) => {
+    if (m.type() === 'error' && !m.text().includes('NG0100')) errors.push(m.text().split('\n')[0].slice(0, 160));
+  }); // develop already logs NG0100 (ExpressionChangedAfterItHasBeenChecked)
+  const text = (t) => page.getByText(t, { exact: true });
+  const button = (name) => page.getByRole('button', { name, exact: true });
+  const tree = page.getByRole('tree');
+  const absent = async (name) => { if (await button(name).isVisible()) throw new Error(`"${name}" is shown`); };
+  const shot = async (name, look) => {
+    await page.screenshot({ path: `${OUT}/${name}.png` });
+    lines.push(`    look: ${OUT}/${name}.png: ${look}`);
+  };
+  const check = async (name, steps) => {
+    const at = lines.length;
+    try {
+      await steps();
+      lines.splice(at, 0, `[x] ${name}`);
+    } catch (e) {
+      lines.push(`[ ] ${name}: ${String(e.message).split('\n')[0]}`);
+    }
+  };
+
+  await check('1 page loads in real time', async () => {
+    await page.goto(`${URL}/graph`);
+    await text('Real Time').waitFor({ timeout: 30000 });
+    for (const b of ['Pause', 'Time Range', 'Select Run', 'Clear Graph', 'Custom']) await button(b).waitFor({ timeout: 2000 });
+    await page.getByRole('combobox', { name: 'Quick Select' }).waitFor({ timeout: 2000 });
+    await absent('Realtime');
+  });
+  await check('2 topic from the tree draws live', async () => {
+    const node = (name) => tree.getByRole('treeitem').filter({ has: page.getByText(name, { exact: true }) }).last(); // innermost
+    for (const name of ['BMS', 'Segment_Total_Volt']) await node(name).locator('.p-tree-node-toggle-button').first().click();
+    await tree.getByText('0', { exact: true }).first().click();
+    await page.waitForURL(/topics=BMS%2FSegment_Total_Volt%2F0/, { timeout: 5000 });
+    await page.waitForTimeout(3000);
+    await shot('02-live-topic', 'a live series is drawn');
+  });
+  await check(`3 seeded run #${RUN}`, async () => {
+    await button('Select Run').click();
+    await page.locator('.run-card').first().waitFor({ timeout: 10000 });
+    await page.evaluate((id) => {
+      const card = [...document.querySelectorAll('.run-card')]
+        .find((c) => [...c.querySelectorAll('*')].some((e) => !e.childElementCount && e.textContent.trim() === 'Run #' + id));
+      const pick = card?.parentElement?.querySelector('.run-select-button button');
+      if (!pick) throw new Error(`no Run #${id} in the Select Run dialog`);
+      pick.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true })); // under a PrimeNG overlay
+    }, RUN);
+    await page.locator('.run-card').first().waitFor({ state: 'detached', timeout: 5000 });
+    await text(`Run #${RUN}`).waitFor({ timeout: 10000 });
+    await button('Realtime').waitFor({ timeout: 2000 });
+    await absent('Pause');
+    await page.waitForTimeout(3000);
+    await shot('03-seeded-run', 'x-axis spans 50 hours, with a dated day-boundary line at each of the two midnights');
+  });
+  await check('4 historical Quick Select', async () => {
+    await button('Realtime').click();
+    await text('Real Time').waitFor({ timeout: 5000 });
+    await page.getByRole('combobox', { name: 'Quick Select' }).click();
+    const options = await page.getByRole('option').count();
+    if (options !== 11) throw new Error(`${options} Quick Select options, not 11`);
+    await page.getByRole('option', { name: '5 minutes', exact: true }).click();
+    await text('Historical').waitFor({ timeout: 5000 });
+    await absent('Pause');
+    await page.waitForTimeout(3000);
+    await shot('04-historical-5-min', 'x-axis about 5 minutes, or since the data starts');
+  });
+  await check('5 back to real time', async () => {
+    await button('Realtime').click();
+    await text('Real Time').waitFor({ timeout: 5000 });
+    await page.waitForTimeout(10000);
+    await shot('05-real-time-after', 'x-axis about 30 seconds, not the whole session');
+  });
+  await check('6 no new console errors', async () => {
+    if (errors.length) throw new Error(`${errors.length}, first: ${errors[0]}`);
+  });
+  return lines.join('\n');
+}
diff --git a/.claude/skills/verify-graph/scripts/check.sh b/.claude/skills/verify-graph/scripts/check.sh
new file mode 100755
index 0000000..c8710cd
--- /dev/null
+++ b/.claude/skills/verify-graph/scripts/check.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# check.sh <branch> <base-url>: run the base verify-graph checks (check.js) in <branch>'s playwright-cli
+# session, opening it if needed, against the seeded multi-day run. Prints one `[x]`/`[ ]` line per check
+# and `look:` lines for screenshots in pictures/<branch>/verify-graph/; exits 1 if a check failed.
+set -euo pipefail
+here=$(cd "$(dirname "$0")" && pwd)
+branch=${1:?usage: check.sh <branch> <base-url>}; url=${2:?usage: check.sh <branch> <base-url>}; url=${url%/}
+run=$(bash "$here/seed.sh")
+out=${DELPHI_ROOT:?unset: start the session at the workspace root}/pictures/$branch/verify-graph
+playwright-cli list | grep -q "^- $branch:" || bash "$here/open.sh" "$branch" "$url/graph" >/dev/null
+code=$(sed -e "s|__URL__|$url|; s|__RUN__|$run|; s|__OUT__|$out|" "$here/check.js")
+result=$(playwright-cli -s="$branch" --raw run-code "$code" | node -e 'process.stdout.write(JSON.parse(require("fs").readFileSync(0, "utf8")))')
+echo "$result"
+! grep -q '^\[ \]' <<<"$result"
diff --git a/.claude/skills/verify-graph/scripts/open.sh b/.claude/skills/verify-graph/scripts/open.sh
new file mode 100755
index 0000000..5a1b49b
--- /dev/null
+++ b/.claude/skills/verify-graph/scripts/open.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# open.sh <branch> <url>: open a playwright-cli session named <branch> on <url>, so parallel checks don't
+# share a browser. Its output (snapshots, console logs, unnamed screenshots) goes to pictures/<branch>/;
+# its config, and any throwaway Playwright code, to .playwright-cli/<branch>/. Both are gitignored. Uses
+# the preinstalled Chromium in cloud containers (/opt/pw-browsers); elsewhere, Playwright's own
+# (`playwright-cli install-browser`).
+set -euo pipefail
+branch=${1:?usage: open.sh <branch> <url>}; url=${2:?usage: open.sh <branch> <url>}
+root=${DELPHI_ROOT:?unset: start the session at the workspace root}
+out=$root/pictures/$branch scratch=$root/.playwright-cli/$branch
+mkdir -p "$out" "$scratch"
+launch=; [ -x /opt/pw-browsers/chromium ] && launch=',"launchOptions":{"executablePath":"/opt/pw-browsers/chromium","headless":true}'
+printf '{"browser":{"browserName":"chromium"%s},"outputDir":"%s"}\n' "$launch" "$out" >"$scratch/cli.config.json"
+playwright-cli -s="$branch" open --config="$scratch/cli.config.json" "$url"
diff --git a/.claude/skills/verify-graph/scripts/seed.sh b/.claude/skills/verify-graph/scripts/seed.sh
new file mode 100755
index 0000000..fdb2631
--- /dev/null
+++ b/.claude/skills/verify-graph/scripts/seed.sh
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# seed.sh: make sure the local database holds verify-graph's multi-day run, and print its id. The run is
+# 50 hours of BMS/Segment_Total_Volt/0, one point every 30s, from noon UTC four days ago, so it crosses
+# two midnights in any time zone and stays out of the 24-hour Quick Select window. Parallel checks share
+# one run: it is made once, under a lock, and found by its notes after that.
+set -euo pipefail
+db=$(docker ps --filter name=odyssey-db --format '{{.Names}}' | head -1)
+[ -n "$db" ] || { echo "seed: no odyssey-db container; start the backend with run-local first" >&2 && exit 1; }
+sql() { docker exec -i "$db" psql -U postgres -v ON_ERROR_STOP=1 -qAt "$@"; }
+tag='verify-graph multi-day seed'
+state=${TMPDIR:-/tmp}; state=${state%/}/argos-run-local; mkdir -p "$state"
+lock=$state/seed.lock
+n=0; until mkdir "$lock" 2>/dev/null; do n=$((n + 1)); [ $n -lt 600 ] || rm -rf "$lock"; sleep 0.1; done # stale after 60s
+trap 'rmdir "$lock" 2>/dev/null || true' EXIT
+id=$(sql -c "select \"runId\" from run where notes = '$tag' limit 1")
+[ -n "$id" ] || id=$(sql <<SQL
+insert into data_type (name, unit) values ('BMS/Segment_Total_Volt/0', 'V') on conflict do nothing;
+with r as (
+  insert into run ("driverName", "locationName", notes, time)
+  values ('verify-graph', 'seed', '$tag', date_trunc('day', now()) - interval '84 hours')
+  returning "runId", time
+), d as (
+  insert into data (values, time, "dataTypeName", "runId")
+  select array[400 + 20 * sin(s / 3600.0)]::real[], (extract(epoch from r.time) * 1e6)::bigint + s * 1000000::bigint,
+    'BMS/Segment_Total_Volt/0', r."runId"
+  from r, generate_series(0, 50 * 3600, 30) s
+)
+select "runId" from r;
+SQL
+)
+echo "$id"
diff --git a/.claude/skills/verify-graph/scripts/select-run.sh b/.claude/skills/verify-graph/scripts/select-run.sh
new file mode 100755
index 0000000..d1237c4
--- /dev/null
+++ b/.claude/skills/verify-graph/scripts/select-run.sh
@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+# select-run.sh <branch> <run-id>: with the Select Run dialog open in <branch>'s session, pick run
+# <run-id>. The carousel autoplays and its "Select this Run" button sits under a PrimeNG overlay, so this
+# finds the run's card by id and clicks its button with a synthetic event instead of `playwright-cli click`.
+set -euo pipefail
+branch=${1:?usage: select-run.sh <branch> <run-id>}; id=${2:?usage: select-run.sh <branch> <run-id>}
+case $id in '' | *[!0-9]*) echo "select-run: run id must be a number, got '$id'" >&2 && exit 1 ;; esac
+playwright-cli -s="$branch" run-code "async (page) => {
+  await page.waitForSelector('.run-card');
+  const found = await page.evaluate((id) => {
+    const card = [...document.querySelectorAll('.run-card')]
+      .find((c) => [...c.querySelectorAll('*')].some((e) => !e.childElementCount && e.textContent.trim() === 'Run #' + id));
+    const button = card?.parentElement?.querySelector('.run-select-button button');
+    button?.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+    return !!button;
+  }, $id);
+  if (!found) throw new Error('select-run: no Run #$id in the Select Run dialog');
+}"

From 6f8f1949853031a3de3358c22f35f0ce3ce5161a Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 18 Oct 2026 17:20:11 +0000
Subject: [PATCH 04/19] delphi: sync .delphi/ from main

---
 .delphi/manifest.yml                     |  3 +-
 .delphi/migrations/0.8.0-dotted-names.sh | 52 ++++++++++++++++++++++++
 .delphi/names.sh                         | 27 ++++++++++++
 .delphi/park.sh                          | 14 ++++---
 .delphi/paths.sh                         |  2 +-
 .delphi/setup.sh                         | 23 ++++++-----
 .delphi/switch.sh                        | 34 +++++++---------
 .delphi/versions                         |  1 +
 8 files changed, 118 insertions(+), 38 deletions(-)
 create mode 100644 .delphi/migrations/0.8.0-dotted-names.sh
 create mode 100644 .delphi/names.sh

diff --git a/.delphi/manifest.yml b/.delphi/manifest.yml
index aa8eb88..5fe7475 100644
--- a/.delphi/manifest.yml
+++ b/.delphi/manifest.yml
@@ -6,7 +6,7 @@
 #   MINOR  something new that existing clones need nothing for
 #   MAJOR  clones need cleanup (MINOR while 0.x): add .delphi/migrations/<version>-<slug>.sh, which
 #          setup.sh runs once per workspace in each clone (rules in Delphi's CLAUDE.md)
-version: 0.7.0
+version: 0.8.0
 files:                        # repo-relative paths; a trailing / means everything under it
   - .delphi/manifest.yml
   - .delphi/.gitattributes
@@ -18,5 +18,6 @@ files:                        # repo-relative paths; a trailing / means everythi
   - .delphi/plugins.sh
   - .delphi/switch.sh
   - .delphi/park.sh
+  - .delphi/names.sh
   - .delphi/migrations/
   - .github/workflows/delphi.yml
diff --git a/.delphi/migrations/0.8.0-dotted-names.sh b/.delphi/migrations/0.8.0-dotted-names.sh
new file mode 100644
index 0000000..2f9781d
--- /dev/null
+++ b/.delphi/migrations/0.8.0-dotted-names.sh
@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# 0.8.0: a workspace's name is its folders' short names and its own, joined by dots (.delphi/names.sh:
+# s.app.argos.argos-dev, branch ws/s.app.argos.argos-dev; was its folder's path without workspaces/,
+# software/application-software/argos/argos-dev), and `workspaces:` entries (`- <name>` or `- main`)
+# are copied to linked/<name>. Moves what this clone keeps under old names to the new ones, for every
+# workspace on main: parked slots (.delphi/parked/<old> to .delphi/parked/<name>), read-only copies
+# (linked/ws/<old> to linked/<name>, here and in each parked slot), and version records
+# (delphi.<old>.* in git config). Then, if this clone is on ws/<old>, renames that branch ws/<name>
+# tracking origin/ws/<name> (sync pushed both to the same commit); a local ws/<name> already there is
+# replaced only if this branch has all its commits. Only renames; a name taken at both places is
+# reported and left.
+set -euo pipefail
+git fetch -q origin 2>/dev/null || echo "migrate: could not fetch; using the last fetched" >&2
+git rev-parse -q --verify refs/remotes/origin/main >/dev/null ||
+  { echo "migrate: no origin/main here; git fetch origin main, then re-run setup" >&2 && exit 1; }
+pairs=$(bash .delphi/names.sh refs/remotes/origin/main | awk '{ sub("/workspaces/", "/", $2); print $2 "|" $1 }') # <old>|<name>
+move() { # <from> <to>
+  [ -e "$1" ] || return 0
+  if [ -e "$2" ]; then echo "migrate: $1 and $2 both exist; left $1 (move what you need by hand)" >&2 && return 0; fi
+  mkdir -p "$(dirname "$2")" && mv "$1" "$2" && echo "migrate: moved $1 to $2"
+}
+for p in $pairs; do
+  old=${p%|*} n=${p#*|}
+  move ".delphi/parked/$old" ".delphi/parked/$n"
+  (cd .delphi/parked 2>/dev/null && rmdir -p "${old%/*}" 2>/dev/null) || true # the old name's emptied folders
+  if git config --get-regexp "^delphi\\.$old\\." >/dev/null; then
+    if git config "delphi.$n.version" >/dev/null; then git config --remove-section "delphi.$old"
+    else git config --rename-section "delphi.$old" "delphi.$n"; fi
+  fi
+done
+for slot in . $(for p in $pairs; do [ ! -d ".delphi/parked/${p#*|}" ] || echo ".delphi/parked/${p#*|}"; done); do
+  for p in $pairs; do
+    old=${p%|*}
+    move "$slot/linked/ws/$old" "$slot/linked/${p#*|}"
+    (cd "$slot/linked" 2>/dev/null && rmdir -p "ws/${old%/*}" 2>/dev/null) || true
+  done
+done
+
+cur=$(git branch --show-current)
+for p in $pairs; do
+  n=${p#*|}
+  [ "$cur" = "ws/${p%|*}" ] || continue
+  if git rev-parse -q --verify "refs/heads/ws/$n" >/dev/null; then
+    git merge-base --is-ancestor "ws/$n" HEAD ||
+      { echo "migrate: local ws/$n has commits $cur doesn't; merge or delete it (git branch -D ws/$n), then re-run setup" >&2 && exit 1; }
+  fi
+  git branch -M "$cur" "ws/$n"
+  if git rev-parse -q --verify "refs/remotes/origin/ws/$n" >/dev/null; then
+    git branch -q -u "origin/ws/$n" "ws/$n"
+    echo "migrate: renamed this branch $cur to ws/$n, tracking origin/ws/$n"
+  else echo "migrate: renamed this branch $cur to ws/$n; once CI creates origin/ws/$n: git branch -u origin/ws/$n"; fi
+done
diff --git a/.delphi/names.sh b/.delphi/names.sh
new file mode 100644
index 0000000..426ea7d
--- /dev/null
+++ b/.delphi/names.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# .delphi/names.sh [<rev>]: print `<name> <folder>` for each workspace folder software/**/workspaces/<leaf>/
+# in <rev> (default: the working tree here, a main checkout), sorted by folder. A workspace's name is
+# the short name of each folder from software/ down to its project folder, then <leaf>, joined by
+# dots (software/application-software/argos/workspaces/argos-dev -> s.app.argos.argos-dev; branch
+# ws/<name>). A folder's short name is the one line in its `short-name` file, else its own name.
+# Prints nothing where there's no software/ (a ws/* branch). Bash 3.2 and Git Bash safe.
+set -euo pipefail
+rev=${1:-}
+folders() {
+  if [ -n "$rev" ]; then git ls-tree -r --name-only "$rev" -- software
+  else find software -type f -name workspace.yml 2>/dev/null; fi | sed -nE 's#^(software/(.+/)?workspaces/[^/]+)/workspace\.yml$#\1#p' | LC_ALL=C sort
+}
+short() { # <folder>: its short name
+  local s
+  if [ -n "$rev" ]; then s=$(git show "$rev:$1/short-name" 2>/dev/null || true); else s=$(cat "$1/short-name" 2>/dev/null || true); fi
+  s=$(printf '%s' "$s" | tr -d '[:space:]')
+  echo "${s:-${1##*/}}"
+}
+for f in $(folders); do
+  n="" p=""
+  for part in $(echo "${f%/workspaces/*}" | tr / ' '); do
+    p=${p:+$p/}$part
+    n="$n$(short "$p")."
+  done
+  echo "$n${f##*/} $f"
+done
diff --git a/.delphi/park.sh b/.delphi/park.sh
index cafb387..cb405c0 100755
--- a/.delphi/park.sh
+++ b/.delphi/park.sh
@@ -2,20 +2,22 @@
 # .delphi/park.sh <prev> <new> <branch-flag>: run by the post-checkout hook .delphi/setup.sh writes,
 # from the worktree that checked out. .delphi/ is on every branch, main included, so the hook always
 # finds it, the version just checked out. When a checkout moves this clone to another workspace
-# (the `name:` in workspace.yml, its place in the tree; none on main), it parks the old workspace's
+# (the `name:` in workspace.yml; none on main), it parks the old workspace's
 # root folders (the ones .delphi/paths.sh names, .journal/, and those under `park:` in the workspace.yml
 # of the branch it leaves) at .delphi/parked/<name>/ (git-ignored by .delphi/.gitignore), and brings
-# back everything parked for the new one. A name from before workspaces were named by
-# path (argos-dev) is the same workspace as the path ending in it, so moving onto the renamed branch
-# moves nothing. Moves are renames, so every path is the same again once its workspace is checked
+# back everything parked for the new one. A workspace's dotted name and its old one, its folder's
+# path (s.app.argos.argos-dev, software/application-software/argos/argos-dev), are taken to be the
+# same workspace when their last parts match, so moving onto the renamed branch moves nothing. Moves are renames, so every path is the same again once its workspace is checked
 # out. Runs on bash 3.2 and Git Bash.
 set -euo pipefail
 [ "${3:-0}" = 1 ] || exit 0
 name() { git show "$1:workspace.yml" 2>/dev/null | awk '/^name:/ { print $2; exit }' || true; }
 old=$(name "$1") new=$(name "$2")
 [ "$old" != "$new" ] || exit 0
-case "$old" in */*) ;; ?*) [ "$old" != "${new##*/}" ] || exit 0 ;; esac # renamed by path: still the same workspace
-case "$new" in */*) ;; ?*) [ "$new" != "${old##*/}" ] || exit 0 ;; esac
+last() { local n=${1##*/}; echo "${n##*.}"; }   # a name's last part, after its last / or .
+slashed() { case "$1" in */*) echo 1 ;; esac; } # an old name, its folder's path
+[ -z "$old" ] || [ -z "$new" ] || [ "$(slashed "$old")" = "$(slashed "$new")" ] || [ "$(last "$old")" != "$(last "$new")" ] ||
+  exit 0 # its old name and its new one: still the same workspace
 top=$(git rev-parse --show-toplevel)
 park=$top/.delphi/parked
 parks() { # <commit>: the root folders its workspace parks
diff --git a/.delphi/paths.sh b/.delphi/paths.sh
index 1c0c27e..e763ad3 100644
--- a/.delphi/paths.sh
+++ b/.delphi/paths.sh
@@ -9,7 +9,7 @@ DELPHI_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
 DELPHI_REPOS=$DELPHI_ROOT/repos               # bare stores: repos/<repo>
 DELPHI_WORKTREES=$DELPHI_ROOT/worktrees       # checkouts: worktrees/<repo>/<branch>
 DELPHI_REFERENCES=$DELPHI_ROOT/references     # read-only dependency sources: references/<name>
-DELPHI_LINKED=$DELPHI_ROOT/linked             # read-only Delphi copies: linked/<branch>
+DELPHI_LINKED=$DELPHI_ROOT/linked             # read-only Delphi copies: linked/<workspace>, linked/main
 export DELPHI_ROOT DELPHI_REPOS DELPHI_WORKTREES DELPHI_REFERENCES DELPHI_LINKED
 [ "${BASH_SOURCE[0]:-}" != "$0" ] || printf 'export DELPHI_ROOT=%q DELPHI_REPOS=%q DELPHI_WORKTREES=%q DELPHI_REFERENCES=%q DELPHI_LINKED=%q\n' \
   "$DELPHI_ROOT" "$DELPHI_REPOS" "$DELPHI_WORKTREES" "$DELPHI_REFERENCES" "$DELPHI_LINKED"
diff --git a/.delphi/setup.sh b/.delphi/setup.sh
index ecb2a62..185ef31 100755
--- a/.delphi/setup.sh
+++ b/.delphi/setup.sh
@@ -5,14 +5,15 @@
 # out its default branch as the first worktree, worktrees/<name>/<default-branch>. For each repo under
 # `references-git:` (read-only dependency sources, `<name>: <git-url> [<ref>]`), checks out a shallow,
 # detached copy of <ref> (default: origin's default branch) at references/<name>, refreshed on every
-# run, with pushes disabled. Each entry under `workspaces:` (`- ws/<name>` or `- main`, a workspace
-# being named by its place in the tree) gets the same kind of copy of that branch of this clone's
-# origin (Delphi), at linked/<branch>; to edit one, switch this clone to it (.delphi/switch.sh). Adds the
+# run, with pushes disabled. Each entry under `workspaces:` (`- <name>`, a workspace's dotted name
+# from .delphi/names.sh, or `- main`) gets the same kind of copy of that branch of this clone's
+# origin (Delphi, ws/<name> or main), at linked/<name>; to edit one, switch this clone to it (.delphi/switch.sh). Adds the
 # folders park.sh parks and macOS's .DS_Store to this clone's .git/info/exclude, and writes its post-checkout hook, which runs .delphi/park.sh (on
 # every branch) as just checked out in the worktree that checked out (unless another hook is there), so switching
 # to another workspace or main parks those folders. First
 # it runs the .delphi/migrations/<version>-*.sh this workspace hasn't (oldest first; the last one done
-# is `git config delphi.<name>.version`, 0.0.0 if unset), stopping at one that fails, and warns if
+# is `git config delphi.<name>.version`, else the record under its old name, its folder's path without
+# workspaces/, from origin/main; 0.0.0 if neither), stopping at one that fails, and warns if
 # .delphi/ isn't exactly the version it says (.delphi/version.sh). Last, it brings this machine's Delphi plugins in
 # step with the workspace (.delphi/plugins.sh: installs what it enables, uninstalls local ones it doesn't and what the marketplace dropped). Safe to re-run. Keep it bash 3.2
 # (macOS) and Git Bash safe: no bash-4 features, POSIX awk only.
@@ -20,7 +21,7 @@ set -euo pipefail
 cd "$(dirname "$0")/.."
 [ -f workspace.yml ] || { echo "setup: no workspace.yml here (on main?); nothing to set up" >&2 && exit 0; }
 self=$(awk '/^name:/ { print $2; exit }' workspace.yml)
-case "$self" in "" | [-/]* | */ | *//* | *[!a-z0-9/-]*) echo "setup: workspace.yml needs a valid name:" >&2 && exit 1 ;; esac
+case "$self" in "" | [-.]* | *. | *..* | *[!a-z0-9.-]*) echo "setup: workspace.yml needs a valid name:" >&2 && exit 1 ;; esac
 
 older() { # <a> <b>: a is a lower MAJOR.MINOR.PATCH than b
   [ "$1" != "$2" ] && [ "$(printf '%s\n%s\n' "$1" "$2" | sort -t. -k1,1n -k2,2n -k3,3n | head -n 1)" = "$1" ]
@@ -28,7 +29,8 @@ older() { # <a> <b>: a is a lower MAJOR.MINOR.PATCH than b
 here=$(bash .delphi/version.sh) released=$(grep -v '^#' .delphi/versions | grep . | tail -n 1 | cut -d' ' -f1,2 || true)
 [ "$here" = "$released" ] ||
   echo "setup: .delphi/ is not Delphi ${released%% *} as released (edited here? change it only through main)" >&2
-have=$(git config "delphi.$self.version" || echo 0.0.0)
+old=$(bash .delphi/names.sh refs/remotes/origin/main 2>/dev/null | awk -v n="$self" '$1 == n { sub("/workspaces/", "/", $2); print $2 }' || true)
+have=$(git config "delphi.$self.version" || { [ -n "$old" ] && git config "delphi.$old.version"; } || echo 0.0.0)
 pending=$(for f in .delphi/migrations/*.sh; do [ ! -e "$f" ] || echo "${f##*/}"; done | sort -t. -k1,1n -k2,2n -k3,3n)
 while IFS= read -r f; do
   v=${f%%-*}
@@ -66,10 +68,11 @@ readonly_copy() { # <dir> <url> [<ref>]: shallow, detached, push-disabled checko
   fi
 }
 
-link() { # ws/<name>|main: a read-only copy of that branch of Delphi at linked/<branch>
-  case "$1" in main | ws/[a-z0-9]*) ;; *) echo "setup: skipping bad workspaces: entry '$1'" >&2 && return ;; esac
-  case "$1" in "ws/$self") return ;; */ | *//* | *[!a-z0-9/-]*) echo "setup: skipping bad workspaces: entry '$1'" >&2 && return ;; esac
-  readonly_copy "linked/$1" "$(git remote get-url origin)" "$1"
+link() { # <name>|main: a read-only copy of that workspace's branch of Delphi (ws/<name>), or main, at linked/<name>
+  case "$1" in "$self") return ;; "" | [-.]* | *. | *..* | *[!a-z0-9.-]*)
+    echo "setup: skipping bad workspaces: entry '$1' (want a workspace's name, like s.app.argos.argos-dev, or main)" >&2 && return ;;
+  esac
+  readonly_copy "linked/$1" "$(git remote get-url origin)" "$([ "$1" = main ] && echo main || echo "ws/$1")"
 }
 
 while read -r kind name url ref; do
diff --git a/.delphi/switch.sh b/.delphi/switch.sh
index 0e6afb7..72aa889 100755
--- a/.delphi/switch.sh
+++ b/.delphi/switch.sh
@@ -1,33 +1,27 @@
 #!/usr/bin/env bash
 # .delphi/switch.sh <workspace>|main: move this clone to Delphi's ws/<workspace> (or main). A workspace
-# is named by its place in the tree (software/application-software/argos/argos-dev; ws/ in front is
-# fine), or by its last part alone (argos-dev) if only one workspace ends in it. Refuses if
-# tracked files have changes (they would follow the switch), fetches the branch, switches to it (the
-# local branch, else a new one tracking origin), fast-forwards it to origin, then runs the new
-# workspace's .delphi/setup.sh (none for main). The post-checkout hook (.delphi/park.sh) parks this workspace's
-# repos/, worktrees/, references/ and linked/ and restores the new one's. Runs on bash 3.2 and Git Bash.
-# .delphi/switch.sh --list: fetch the ws/* branches, then print main and each workspace's name, one a
-# line, `* ` before this clone's and two spaces before the others (the delphi mod's /ws-delphi pane reads it).
+# is named by .delphi/names.sh (s.app.argos.argos-dev; ws/ in front is fine). Refuses if tracked files have changes (they would follow the
+# switch), fetches the branch, switches to it (the local branch, else a new one tracking origin),
+# fast-forwards it to origin, then runs the new workspace's .delphi/setup.sh (none for main). The
+# post-checkout hook (.delphi/park.sh) parks this workspace's repos/, worktrees/, references/ and
+# linked/ and restores the new one's. Runs on bash 3.2 and Git Bash.
+# .delphi/switch.sh --list: fetch main and the ws/* branches, then print main and each workspace on
+# main that has its branch, one a line, as `<name> <its project folder>`, `* ` before this clone's
+# and two spaces before the others (the delphi mod's /ws-delphi pane reads it).
 set -euo pipefail
 { # one block, so bash has read all of it before the switch replaces this file
   cd "$(dirname "$0")/.."
   if [ "${1:-}" = --list ]; then
-    git fetch -q --prune origin '+refs/heads/ws/*:refs/remotes/origin/ws/*' ||
-      echo "switch: could not fetch the ws/* branches; listing the ones last fetched" >&2
-    { echo main && git for-each-ref --format='%(refname:lstrip=3)' refs/remotes/origin/ws/; } |
-      awk -v here="$(git branch --show-current)" '$0 == "main" || /^ws\/.*\// { # not ws/<leaf>: an old name
-        n = $0; sub(/^ws\//, "", n); print ($0 == here ? "* " : "  ") n }'
+    git fetch -q --prune origin '+refs/heads/main:refs/remotes/origin/main' '+refs/heads/ws/*:refs/remotes/origin/ws/*' ||
+      echo "switch: could not fetch main and the ws/* branches; listing the ones last fetched" >&2
+    { echo main && bash .delphi/names.sh refs/remotes/origin/main | while read -r n f; do
+        ! git rev-parse -q --verify "refs/remotes/origin/ws/$n" >/dev/null || echo "$n ${f%/workspaces/*}"
+      done; } | awk -v here="$(git branch --show-current)" '{ print (($1 == "main" ? "main" : "ws/" $1) == here ? "* " : "  ") $0 }'
     exit
   fi
   name=${1:?usage: switch.sh <workspace>|main}
   name=${name#ws/} ref=ws/${name#ws/}
-  case "$name" in main) ref=main ;; "" | [-/]* | */ | *//* | *[!a-z0-9/-]*) echo "switch: bad workspace name '$1'" >&2 && exit 1 ;; esac
-  if [ "$ref" != main ] && [ "$name" = "${name##*/}" ]; then # its last part alone: find the one workspace it names
-    git fetch -q origin '+refs/heads/ws/*:refs/remotes/origin/ws/*' || { echo "switch: could not fetch the ws/* branches" >&2 && exit 1; }
-    ref=$(git for-each-ref --format='%(refname:lstrip=3)' refs/remotes/origin/ws/ | grep "^ws/.*/$name\$" || true) # not ws/<name>: an old name
-    [ -n "$ref" ] && [ "$(echo "$ref" | wc -l)" -eq 1 ] ||
-      { echo "switch: no one workspace ends in '$name' (found: $(echo "${ref:-none}" | tr '\n' ' ')); give its full name" >&2 && exit 1; }
-  fi
+  case "$name" in main) ref=main ;; "" | [-.]* | *. | *..* | *[!a-z0-9.-]*) echo "switch: bad workspace name '$1'" >&2 && exit 1 ;; esac
   git diff --quiet HEAD -- || { echo "switch: commit or set aside your changes first (git status)" >&2 && exit 1; }
   git fetch -q origin "+refs/heads/$ref:refs/remotes/origin/$ref" || { echo "switch: could not fetch $ref" >&2 && exit 1; }
   git switch -q "$ref"
diff --git a/.delphi/versions b/.delphi/versions
index cab1212..4f5c8a5 100644
--- a/.delphi/versions
+++ b/.delphi/versions
@@ -12,3 +12,4 @@
 0.5.1 3fd96f222b77 the delphi mod's command is /ws-delphi (was /ws); switch.sh's comment says so
 0.6.0 c65ffc578bfa setup.sh (.delphi/plugins.sh) makes each clone's @delphi plugins what its workspace enables (installs them, uninstalls local ones it doesn't) and uninstalls ones the marketplace dropped, instead of warning; plugin changes need no migration
 0.7.0 84df5ce802db park.sh also parks .journal/ and the root folders under a workspace's park: in workspace.yml (each workspace its own), restores everything parked for a workspace, and skips bad entries; setup.sh excludes them
+0.8.0 05d4c954a946 workspaces are named by their folders' short names and leaf, joined by dots (.delphi/names.sh, short-name files; ws/s.app.argos.argos-dev, was ws/software/…/argos-dev); workspaces: entries are - <name> | - main, copied to linked/<name>; sync carries ws/<old> over once (migration)

From 852491766fb39f4bcaf3426f1c5ceec86036a2d7 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 18 Oct 2026 17:20:11 +0000
Subject: [PATCH 05/19] delphi: sync inherited files from main

---
 .claude/skills/setup-workspace/SKILL.md  | 6 +++---
 .claude/skills/switch-workspace/SKILL.md | 5 ++---
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/.claude/skills/setup-workspace/SKILL.md b/.claude/skills/setup-workspace/SKILL.md
index 6e73fb3..5343a5a 100644
--- a/.claude/skills/setup-workspace/SKILL.md
+++ b/.claude/skills/setup-workspace/SKILL.md
@@ -3,7 +3,7 @@ name: setup-workspace
 description: Change what this workspace checks out and re-run its setup. workspace.yml lists code repos (repos:), read-only dependency sources (references-git:), and read-only copies of other Delphi workspaces or main (workspaces:). Use when the user wants to read or compare another workspace's or main's instructions, skills, or docs (link it), add or remove a repo or dependency reference, or run setup after cloning or pulling.
 ---
 
-`workspace.yml` at the workspace root lists what `.delphi/setup.sh` checks out, all git-ignored: code repos (`repos:`), dependency sources (`references-git:`), and other Delphi workspaces or main (`workspaces:`, entries `- ws/<name>` or `- main`; a workspace's name is its place in the tree, like `software/application-software/argos/argos-dev`). The comment on each section gives its entry format and where it lands; read it, then edit the file.
+`workspace.yml` at the workspace root lists what `.delphi/setup.sh` checks out, all git-ignored: code repos (`repos:`), dependency sources (`references-git:`), and other Delphi workspaces or main (`workspaces:`, entries `- <name>` or `- main`; a workspace's name is the short names of its folders (each folder's `short-name` file, else its name) and its own folder name, joined by dots, like `s.app.argos.argos-dev`; `bash .delphi/switch.sh --list` lists them). The comment on each section gives its entry format and where it lands; read it, then edit the file.
 
 Run from the workspace root after any change, and to refresh references and workspace copies to their latest:
 
@@ -12,7 +12,7 @@ bash .delphi/setup.sh
 ```
 
 - The copies under `linked/` are for reading: never edit, branch, or push them. To change one of those workspaces or main, switch to it (`switch-workspace` skill).
-- This workspace's project folder (shared context, `AUTHORING.md`, `workspace-defaults/`) is `linked/main/` plus this workspace's name without its last part: for `software/application-software/argos/argos-dev`, `linked/main/software/application-software/argos/`. List workspaces: `git branch -r --list 'origin/ws/*'`.
+- This workspace's project folder (shared context, `AUTHORING.md`, `workspace-defaults/`) is the folder above `workspaces/<leaf>/` in `linked/main/` (`bash .delphi/switch.sh --list` prints it): for `s.app.argos.argos-dev`, `linked/main/software/application-software/argos/`. List workspaces and their project folders: `bash .delphi/switch.sh --list`.
 - `workspace.yml` is shared: change it on a branch and open a PR into `ws/<this-name>` (the `name:` in `workspace.yml`). For a one-off look, add the entry, run setup, then `git restore workspace.yml`.
-- Setup never deletes what you'd lose. A removed entry's `linked/<branch>/`, `references/<name>/`, or repo store and worktrees stay until you delete them (ask first).
+- Setup never deletes what you'd lose. A removed entry's `linked/<name>/`, `references/<name>/`, or repo store and worktrees stay until you delete them (ask first).
 - When Delphi releases a version that needs cleanup in clones, setup runs its migration first (`.delphi/migrations/`), once per workspace. A migration removes only what nothing is lost from, and otherwise stops setup with what to do: tell the user, do it with their go-ahead, and re-run.
diff --git a/.claude/skills/switch-workspace/SKILL.md b/.claude/skills/switch-workspace/SKILL.md
index 4ca2ab9..a29a5df 100644
--- a/.claude/skills/switch-workspace/SKILL.md
+++ b/.claude/skills/switch-workspace/SKILL.md
@@ -6,13 +6,12 @@ description: Switch this clone to another Delphi workspace, or to Delphi's main,
 Run from the workspace root:
 
 ```
-bash .delphi/switch.sh <name>        # ws/<name>: its place in the tree, e.g. software/application-software/argos/argos-dev
-bash .delphi/switch.sh argos-dev     # its last part alone, if only one workspace ends in it
+bash .delphi/switch.sh <name>        # ws/<name>: its dotted name, e.g. s.app.argos.argos-dev
 bash .delphi/switch.sh main          # Delphi's main: project folders, templates, CI
 ```
 
 - The user can also switch from the `/ws-delphi` pane (the `delphi` plugin's mod), which shows them as cards (`bash .delphi/switch.sh --list`): press one, then Switch workspace; `/ws-delphi <name>` switches straight away, and `/ws-delphi --web` opens the same cards in a browser tab.
-- List workspaces: `git branch -r --list 'origin/ws/*'`. A workspace's name is its folder path on main without `workspaces/`.
+- List workspaces and their project folders: `bash .delphi/switch.sh --list`.
 - It refuses while tracked files have changes: commit them on a branch (and PR them) first. Then it fetches, switches, fast-forwards, and runs the new workspace's `.delphi/setup.sh`.
 - The post-checkout hook parks this workspace's `repos/`, `worktrees/`, `references/` and `linked/` in `.delphi/parked/<name>/` (git-ignored; `<name>` as in its `workspace.yml`) and brings the other's back at the same paths, so worktrees and the work in them return as they were. Switch back the same way. Never run `git clean -X` or `git stash --all` at the workspace root: they take ignored files, parked work included.
 - Before switching, stop anything running from `worktrees/` (dev servers, Docker builds): its folder moves.

From d5a80d4c3688b36f78f3c551fc7280364cd374b3 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 18 Oct 2026 17:47:30 +0000
Subject: [PATCH 06/19] delphi: sync .delphi/ from main

---
 .delphi/manifest.yml                      |  2 +-
 .delphi/migrations/0.9.0-linked-clones.sh | 25 +++++++++++++++++++++++
 .delphi/paths.sh                          |  2 +-
 .delphi/setup.sh                          | 20 ++++++++++++++----
 .delphi/versions                          |  1 +
 5 files changed, 44 insertions(+), 6 deletions(-)
 create mode 100755 .delphi/migrations/0.9.0-linked-clones.sh

diff --git a/.delphi/manifest.yml b/.delphi/manifest.yml
index 5fe7475..5f84b1e 100644
--- a/.delphi/manifest.yml
+++ b/.delphi/manifest.yml
@@ -6,7 +6,7 @@
 #   MINOR  something new that existing clones need nothing for
 #   MAJOR  clones need cleanup (MINOR while 0.x): add .delphi/migrations/<version>-<slug>.sh, which
 #          setup.sh runs once per workspace in each clone (rules in Delphi's CLAUDE.md)
-version: 0.8.0
+version: 0.9.0
 files:                        # repo-relative paths; a trailing / means everything under it
   - .delphi/manifest.yml
   - .delphi/.gitattributes
diff --git a/.delphi/migrations/0.9.0-linked-clones.sh b/.delphi/migrations/0.9.0-linked-clones.sh
new file mode 100755
index 0000000..c7ae000
--- /dev/null
+++ b/.delphi/migrations/0.9.0-linked-clones.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# 0.9.0: linked/<name> used to be a shallow, detached, push-disabled copy of ws/<name> (or main);
+# setup.sh now keeps a full clone there, on that branch and tracking origin, with pushes allowed. Turns
+# each old copy here (its push URL is DISABLED-read-only-copy) into one in place: fetches its full
+# history, puts it on a local ws/<name> (or main) at the commit it's on, so nothing in it moves, and
+# allows pushes. setup.sh then pulls it. Parked copies are their own workspace's, migrated when it's
+# set up. Stops at one it can't fetch or that already has a local branch of that name.
+set -euo pipefail
+for d in linked/*/; do
+  d=${d%/}
+  [ -d "$d/.git" ] || continue
+  [ "$(git -C "$d" config remote.origin.pushurl || true)" = DISABLED-read-only-copy ] || continue # a clone already
+  n=${d#linked/} ref=ws/${d#linked/} unshallow=
+  [ "$n" != main ] || ref=main
+  [ "$(git -C "$d" rev-parse --is-shallow-repository)" = false ] || unshallow=--unshallow
+  git -C "$d" fetch -q ${unshallow:+"$unshallow"} origin "+refs/heads/$ref:refs/remotes/origin/$ref" </dev/null ||
+    { echo "migrate: could not fetch $ref into $d; re-run setup when you can reach origin" >&2 && exit 1; }
+  if [ -z "$(git -C "$d" branch --show-current)" ]; then
+    git -C "$d" switch -q -c "$ref" 2>/dev/null ||
+      { echo "migrate: $d already has a branch $ref; git -C $d switch $ref (or delete it), then re-run setup" >&2 && exit 1; }
+  fi
+  ! git -C "$d" rev-parse -q --verify "refs/heads/$ref" >/dev/null || git -C "$d" branch -q -u "origin/$ref" "$ref"
+  git -C "$d" config --unset-all remote.origin.pushurl
+  echo "migrate: $d is a full clone on $ref now"
+done
diff --git a/.delphi/paths.sh b/.delphi/paths.sh
index e763ad3..c502e67 100644
--- a/.delphi/paths.sh
+++ b/.delphi/paths.sh
@@ -9,7 +9,7 @@ DELPHI_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
 DELPHI_REPOS=$DELPHI_ROOT/repos               # bare stores: repos/<repo>
 DELPHI_WORKTREES=$DELPHI_ROOT/worktrees       # checkouts: worktrees/<repo>/<branch>
 DELPHI_REFERENCES=$DELPHI_ROOT/references     # read-only dependency sources: references/<name>
-DELPHI_LINKED=$DELPHI_ROOT/linked             # read-only Delphi copies: linked/<workspace>, linked/main
+DELPHI_LINKED=$DELPHI_ROOT/linked             # Delphi clones to read: linked/<workspace>, linked/main
 export DELPHI_ROOT DELPHI_REPOS DELPHI_WORKTREES DELPHI_REFERENCES DELPHI_LINKED
 [ "${BASH_SOURCE[0]:-}" != "$0" ] || printf 'export DELPHI_ROOT=%q DELPHI_REPOS=%q DELPHI_WORKTREES=%q DELPHI_REFERENCES=%q DELPHI_LINKED=%q\n' \
   "$DELPHI_ROOT" "$DELPHI_REPOS" "$DELPHI_WORKTREES" "$DELPHI_REFERENCES" "$DELPHI_LINKED"
diff --git a/.delphi/setup.sh b/.delphi/setup.sh
index 185ef31..7fbcb06 100755
--- a/.delphi/setup.sh
+++ b/.delphi/setup.sh
@@ -6,8 +6,9 @@
 # `references-git:` (read-only dependency sources, `<name>: <git-url> [<ref>]`), checks out a shallow,
 # detached copy of <ref> (default: origin's default branch) at references/<name>, refreshed on every
 # run, with pushes disabled. Each entry under `workspaces:` (`- <name>`, a workspace's dotted name
-# from .delphi/names.sh, or `- main`) gets the same kind of copy of that branch of this clone's
-# origin (Delphi, ws/<name> or main), at linked/<name>; to edit one, switch this clone to it (.delphi/switch.sh). Adds the
+# from .delphi/names.sh, or `- main`) gets a full clone of this clone's origin (Delphi) at linked/<name>,
+# on ws/<name> (or main) tracking origin; every run switches it back to that branch if it was switched
+# away (its own .delphi/switch.sh) and pulls it. By convention it's read from here, not edited. Adds the
 # folders park.sh parks and macOS's .DS_Store to this clone's .git/info/exclude, and writes its post-checkout hook, which runs .delphi/park.sh (on
 # every branch) as just checked out in the worktree that checked out (unless another hook is there), so switching
 # to another workspace or main parks those folders. First
@@ -68,11 +69,22 @@ readonly_copy() { # <dir> <url> [<ref>]: shallow, detached, push-disabled checko
   fi
 }
 
-link() { # <name>|main: a read-only copy of that workspace's branch of Delphi (ws/<name>), or main, at linked/<name>
+link() { # <name>|main: a clone of Delphi on that workspace's branch (ws/<name>), or main, at linked/<name>
   case "$1" in "$self") return ;; "" | [-.]* | *. | *..* | *[!a-z0-9.-]*)
     echo "setup: skipping bad workspaces: entry '$1' (want a workspace's name, like s.app.argos.argos-dev, or main)" >&2 && return ;;
   esac
-  readonly_copy "linked/$1" "$(git remote get-url origin)" "$([ "$1" = main ] && echo main || echo "ws/$1")"
+  local dir=linked/$1 ref=ws/$1
+  [ "$1" != main ] || ref=main
+  [ ! -f "$dir/.git" ] || { echo "setup: $dir is a worktree, not a clone; skipping it" >&2 && return; }
+  if [ ! -d "$dir/.git" ]; then
+    git clone -q --branch "$ref" "$(git remote get-url origin)" "$dir" </dev/null ||
+      { echo "setup: could not clone $ref into $dir" >&2 && return; }
+  elif [ "$(git -C "$dir" branch --show-current)" != "$ref" ]; then # switched away: back to its own branch first
+    bash "$dir/.delphi/switch.sh" "$1" </dev/null >/dev/null ||
+      { echo "setup: could not switch $dir back to $ref; left it as it is" >&2 && return; }
+  fi
+  git -C "$dir" pull -q --ff-only origin "$ref" </dev/null || echo "setup: could not pull $ref into $dir (see git -C $dir status)" >&2
+  echo "$dir: on $ref ($(git -C "$dir" rev-parse --short HEAD))"
 }
 
 while read -r kind name url ref; do
diff --git a/.delphi/versions b/.delphi/versions
index 4f5c8a5..ed6df10 100644
--- a/.delphi/versions
+++ b/.delphi/versions
@@ -13,3 +13,4 @@
 0.6.0 c65ffc578bfa setup.sh (.delphi/plugins.sh) makes each clone's @delphi plugins what its workspace enables (installs them, uninstalls local ones it doesn't) and uninstalls ones the marketplace dropped, instead of warning; plugin changes need no migration
 0.7.0 84df5ce802db park.sh also parks .journal/ and the root folders under a workspace's park: in workspace.yml (each workspace its own), restores everything parked for a workspace, and skips bad entries; setup.sh excludes them
 0.8.0 05d4c954a946 workspaces are named by their folders' short names and leaf, joined by dots (.delphi/names.sh, short-name files; ws/s.app.argos.argos-dev, was ws/software/…/argos-dev); workspaces: entries are - <name> | - main, copied to linked/<name>; sync carries ws/<old> over once (migration)
+0.9.0 b850821eaa9a linked/<name> are full clones on ws/<name> (or main) tracking origin, pushes allowed; setup.sh switches each back to its branch if switched away and pulls it (migration)

From e51b2f168199fc2a047daf3549ab100b89363892 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 18 Oct 2026 17:47:30 +0000
Subject: [PATCH 07/19] delphi: sync inherited files from main

---
 .claude/skills/setup-workspace/SKILL.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.claude/skills/setup-workspace/SKILL.md b/.claude/skills/setup-workspace/SKILL.md
index 5343a5a..795e46a 100644
--- a/.claude/skills/setup-workspace/SKILL.md
+++ b/.claude/skills/setup-workspace/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: setup-workspace
-description: Change what this workspace checks out and re-run its setup. workspace.yml lists code repos (repos:), read-only dependency sources (references-git:), and read-only copies of other Delphi workspaces or main (workspaces:). Use when the user wants to read or compare another workspace's or main's instructions, skills, or docs (link it), add or remove a repo or dependency reference, or run setup after cloning or pulling.
+description: Change what this workspace checks out and re-run its setup. workspace.yml lists code repos (repos:), read-only dependency sources (references-git:), and clones of other Delphi workspaces or main to read (workspaces:). Use when the user wants to read or compare another workspace's or main's instructions, skills, or docs (link it), add or remove a repo or dependency reference, or run setup after cloning or pulling.
 ---
 
 `workspace.yml` at the workspace root lists what `.delphi/setup.sh` checks out, all git-ignored: code repos (`repos:`), dependency sources (`references-git:`), and other Delphi workspaces or main (`workspaces:`, entries `- <name>` or `- main`; a workspace's name is the short names of its folders (each folder's `short-name` file, else its name) and its own folder name, joined by dots, like `s.app.argos.argos-dev`; `bash .delphi/switch.sh --list` lists them). The comment on each section gives its entry format and where it lands; read it, then edit the file.
@@ -11,7 +11,7 @@ Run from the workspace root after any change, and to refresh references and work
 bash .delphi/setup.sh
 ```
 
-- The copies under `linked/` are for reading: never edit, branch, or push them. To change one of those workspaces or main, switch to it (`switch-workspace` skill).
+- The clones under `linked/` are full clones, each on its branch (`ws/<name>` or `main`) tracking origin, for reading: don't edit, branch, or push them from this workspace. Each setup run switches a clone back to its branch if it was switched away (refused while it has uncommitted changes) and pulls it. To change one of those workspaces or main, work in its own clone or switch to it (`switch-workspace` skill).
 - This workspace's project folder (shared context, `AUTHORING.md`, `workspace-defaults/`) is the folder above `workspaces/<leaf>/` in `linked/main/` (`bash .delphi/switch.sh --list` prints it): for `s.app.argos.argos-dev`, `linked/main/software/application-software/argos/`. List workspaces and their project folders: `bash .delphi/switch.sh --list`.
 - `workspace.yml` is shared: change it on a branch and open a PR into `ws/<this-name>` (the `name:` in `workspace.yml`). For a one-off look, add the entry, run setup, then `git restore workspace.yml`.
 - Setup never deletes what you'd lose. A removed entry's `linked/<name>/`, `references/<name>/`, or repo store and worktrees stay until you delete them (ask first).

From 4189ef4ca28e2a08d3dad393ad74e972c3958f7d Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 18 Oct 2026 18:37:42 +0000
Subject: [PATCH 08/19] delphi: sync .delphi/ from main

---
 .delphi/manifest.yml                          |  2 +-
 .delphi/migrations/1.0.0-workspaces-folder.sh | 16 ++++++++++++++
 .delphi/park.sh                               |  2 +-
 .delphi/paths.sh                              |  8 +++----
 .delphi/setup.sh                              | 21 ++++++++++++-------
 .delphi/switch.sh                             |  2 +-
 .delphi/versions                              |  1 +
 7 files changed, 38 insertions(+), 14 deletions(-)
 create mode 100755 .delphi/migrations/1.0.0-workspaces-folder.sh

diff --git a/.delphi/manifest.yml b/.delphi/manifest.yml
index 5f84b1e..dc3beb2 100644
--- a/.delphi/manifest.yml
+++ b/.delphi/manifest.yml
@@ -6,7 +6,7 @@
 #   MINOR  something new that existing clones need nothing for
 #   MAJOR  clones need cleanup (MINOR while 0.x): add .delphi/migrations/<version>-<slug>.sh, which
 #          setup.sh runs once per workspace in each clone (rules in Delphi's CLAUDE.md)
-version: 0.9.0
+version: 1.0.0
 files:                        # repo-relative paths; a trailing / means everything under it
   - .delphi/manifest.yml
   - .delphi/.gitattributes
diff --git a/.delphi/migrations/1.0.0-workspaces-folder.sh b/.delphi/migrations/1.0.0-workspaces-folder.sh
new file mode 100755
index 0000000..a2a8f16
--- /dev/null
+++ b/.delphi/migrations/1.0.0-workspaces-folder.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# 1.0.0: the clones of the workspaces under `workspaces:` moved from linked/<name> to workspaces/<name>.
+# Moves each one here (a leftover worktree with git worktree move), then removes linked/ if that
+# empties it. Parked ones are their own workspace's, moved when it's set up. Only renames; a name taken
+# at both places is reported and left.
+set -euo pipefail
+[ -d linked ] || exit 0
+mkdir -p workspaces
+for d in linked/*; do
+  [ -e "$d" ] || continue
+  to=workspaces/${d#linked/}
+  if [ -e "$to" ]; then echo "migrate: $d and $to both exist; left $d (move what you need by hand)" >&2 && continue; fi
+  if [ -f "$d/.git" ]; then git worktree move "$d" "$to"; else mv "$d" "$to"; fi
+  echo "migrate: moved $d to $to"
+done
+rmdir linked 2>/dev/null || true
diff --git a/.delphi/park.sh b/.delphi/park.sh
index cb405c0..368c5d0 100755
--- a/.delphi/park.sh
+++ b/.delphi/park.sh
@@ -21,7 +21,7 @@ slashed() { case "$1" in */*) echo 1 ;; esac; } # an old name, its folder's path
 top=$(git rev-parse --show-toplevel)
 park=$top/.delphi/parked
 parks() { # <commit>: the root folders its workspace parks
-  echo repos worktrees references linked .journal
+  echo repos worktrees references workspaces linked .journal # linked: workspaces/ before 1.0.0
   git show "$1:workspace.yml" 2>/dev/null | awk '/^[^[:space:]#]/ { s = /^park:/; next }
     s && /^[[:space:]]+-/ { sub(/^[[:space:]]+-[[:space:]]+/, ""); sub(/[[:space:]]*#.*$/, ""); print }' || true
 }
diff --git a/.delphi/paths.sh b/.delphi/paths.sh
index c502e67..327d6c8 100644
--- a/.delphi/paths.sh
+++ b/.delphi/paths.sh
@@ -9,7 +9,7 @@ DELPHI_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
 DELPHI_REPOS=$DELPHI_ROOT/repos               # bare stores: repos/<repo>
 DELPHI_WORKTREES=$DELPHI_ROOT/worktrees       # checkouts: worktrees/<repo>/<branch>
 DELPHI_REFERENCES=$DELPHI_ROOT/references     # read-only dependency sources: references/<name>
-DELPHI_LINKED=$DELPHI_ROOT/linked             # Delphi clones to read: linked/<workspace>, linked/main
-export DELPHI_ROOT DELPHI_REPOS DELPHI_WORKTREES DELPHI_REFERENCES DELPHI_LINKED
-[ "${BASH_SOURCE[0]:-}" != "$0" ] || printf 'export DELPHI_ROOT=%q DELPHI_REPOS=%q DELPHI_WORKTREES=%q DELPHI_REFERENCES=%q DELPHI_LINKED=%q\n' \
-  "$DELPHI_ROOT" "$DELPHI_REPOS" "$DELPHI_WORKTREES" "$DELPHI_REFERENCES" "$DELPHI_LINKED"
+DELPHI_WORKSPACES=$DELPHI_ROOT/workspaces     # Delphi clones to read: workspaces/<workspace>, workspaces/main
+export DELPHI_ROOT DELPHI_REPOS DELPHI_WORKTREES DELPHI_REFERENCES DELPHI_WORKSPACES
+[ "${BASH_SOURCE[0]:-}" != "$0" ] || printf 'export DELPHI_ROOT=%q DELPHI_REPOS=%q DELPHI_WORKTREES=%q DELPHI_REFERENCES=%q DELPHI_WORKSPACES=%q\n' \
+  "$DELPHI_ROOT" "$DELPHI_REPOS" "$DELPHI_WORKTREES" "$DELPHI_REFERENCES" "$DELPHI_WORKSPACES"
diff --git a/.delphi/setup.sh b/.delphi/setup.sh
index 7fbcb06..0e7f3af 100755
--- a/.delphi/setup.sh
+++ b/.delphi/setup.sh
@@ -6,9 +6,11 @@
 # `references-git:` (read-only dependency sources, `<name>: <git-url> [<ref>]`), checks out a shallow,
 # detached copy of <ref> (default: origin's default branch) at references/<name>, refreshed on every
 # run, with pushes disabled. Each entry under `workspaces:` (`- <name>`, a workspace's dotted name
-# from .delphi/names.sh, or `- main`) gets a full clone of this clone's origin (Delphi) at linked/<name>,
+# from .delphi/names.sh, or `- main`) gets a full clone of this clone's origin (Delphi) at workspaces/<name>,
 # on ws/<name> (or main) tracking origin; every run switches it back to that branch if it was switched
-# away (its own .delphi/switch.sh) and pulls it. By convention it's read from here, not edited. Adds the
+# away (its own .delphi/switch.sh), pulls it, then runs its own setup.sh, so its repos and references are
+# there too. A workspace that is itself one of those (<workspace>/workspaces/<name>) skips its own
+# workspaces:, so setups never chain. By convention they're read from here, not edited. Adds the
 # folders park.sh parks and macOS's .DS_Store to this clone's .git/info/exclude, and writes its post-checkout hook, which runs .delphi/park.sh (on
 # every branch) as just checked out in the worktree that checked out (unless another hook is there), so switching
 # to another workspace or main parks those folders. First
@@ -22,6 +24,8 @@ set -euo pipefail
 cd "$(dirname "$0")/.."
 [ -f workspace.yml ] || { echo "setup: no workspace.yml here (on main?); nothing to set up" >&2 && exit 0; }
 self=$(awk '/^name:/ { print $2; exit }' workspace.yml)
+inside= # set when this is another workspace's workspaces/<name>: its own workspaces: are skipped
+[ "$(basename "$(dirname "$PWD")")" != workspaces ] || [ ! -f ../../workspace.yml ] || [ ! -d ../../.delphi ] || inside=${PWD%/*/*}
 case "$self" in "" | [-.]* | *. | *..* | *[!a-z0-9.-]*) echo "setup: workspace.yml needs a valid name:" >&2 && exit 1 ;; esac
 
 older() { # <a> <b>: a is a lower MAJOR.MINOR.PATCH than b
@@ -69,11 +73,11 @@ readonly_copy() { # <dir> <url> [<ref>]: shallow, detached, push-disabled checko
   fi
 }
 
-link() { # <name>|main: a clone of Delphi on that workspace's branch (ws/<name>), or main, at linked/<name>
-  case "$1" in "$self") return ;; "" | [-.]* | *. | *..* | *[!a-z0-9.-]*)
+link() { # <name>|main: a clone of Delphi on that workspace's branch (ws/<name>), or main, at workspaces/<name>
+  case "$1" in "$self") return 0 ;; "" | [-.]* | *. | *..* | *[!a-z0-9.-]*)
     echo "setup: skipping bad workspaces: entry '$1' (want a workspace's name, like s.app.argos.argos-dev, or main)" >&2 && return ;;
   esac
-  local dir=linked/$1 ref=ws/$1
+  local dir=workspaces/$1 ref=ws/$1
   [ "$1" != main ] || ref=main
   [ ! -f "$dir/.git" ] || { echo "setup: $dir is a worktree, not a clone; skipping it" >&2 && return; }
   if [ ! -d "$dir/.git" ]; then
@@ -85,11 +89,14 @@ link() { # <name>|main: a clone of Delphi on that workspace's branch (ws/<name>)
   fi
   git -C "$dir" pull -q --ff-only origin "$ref" </dev/null || echo "setup: could not pull $ref into $dir (see git -C $dir status)" >&2
   echo "$dir: on $ref ($(git -C "$dir" rev-parse --short HEAD))"
+  [ ! -f "$dir/workspace.yml" ] || # its own setup, which skips its workspaces:
+    bash "$dir/.delphi/setup.sh" </dev/null >/dev/null || echo "setup: $dir's own setup failed (bash $dir/.delphi/setup.sh)" >&2
 }
 
+[ -z "$inside" ] || ! grep -q '^link ' <<<"$list" || echo "setup: in $inside's workspaces/, so this workspace's workspaces: are skipped"
 while read -r kind name url ref; do
   [ -n "$name" ] || continue
-  if [ "$kind" = link ]; then link "$name"; continue; fi
+  if [ "$kind" = link ]; then [ -n "$inside" ] || link "$name"; continue; fi
   case "$name" in . | .. | *[!A-Za-z0-9._-]*) echo "setup: skipping unsafe repo name '$name'" >&2 && continue ;; esac
   if [ "$kind" = ref ]; then readonly_copy "references/$name" "$url" ${ref:+"$ref"} && continue; fi
   store=repos/$name
@@ -118,7 +125,7 @@ EOF2
 
 exclude=$(git rev-parse --git-path info/exclude)
 mkdir -p "$(dirname "$exclude")"
-for d in /repos/ /worktrees/ /references/ /linked/ /.journal/ $(awk '/^[^[:space:]#]/ { s = /^park:/; next }
+for d in /repos/ /worktrees/ /references/ /workspaces/ /.journal/ $(awk '/^[^[:space:]#]/ { s = /^park:/; next }
   s && /^[[:space:]]+-/ { sub(/^[[:space:]]+-[[:space:]]+/, ""); sub(/[[:space:]]*#.*$/, ""); print "/" $0 "/" }' workspace.yml) .DS_Store; do
   grep -qxF "$d" "$exclude" 2>/dev/null || echo "$d" >>"$exclude"
 done
diff --git a/.delphi/switch.sh b/.delphi/switch.sh
index 72aa889..326436a 100755
--- a/.delphi/switch.sh
+++ b/.delphi/switch.sh
@@ -4,7 +4,7 @@
 # switch), fetches the branch, switches to it (the local branch, else a new one tracking origin),
 # fast-forwards it to origin, then runs the new workspace's .delphi/setup.sh (none for main). The
 # post-checkout hook (.delphi/park.sh) parks this workspace's repos/, worktrees/, references/ and
-# linked/ and restores the new one's. Runs on bash 3.2 and Git Bash.
+# workspaces/ and restores the new one's. Runs on bash 3.2 and Git Bash.
 # .delphi/switch.sh --list: fetch main and the ws/* branches, then print main and each workspace on
 # main that has its branch, one a line, as `<name> <its project folder>`, `* ` before this clone's
 # and two spaces before the others (the delphi mod's /ws-delphi pane reads it).
diff --git a/.delphi/versions b/.delphi/versions
index ed6df10..36f014b 100644
--- a/.delphi/versions
+++ b/.delphi/versions
@@ -14,3 +14,4 @@
 0.7.0 84df5ce802db park.sh also parks .journal/ and the root folders under a workspace's park: in workspace.yml (each workspace its own), restores everything parked for a workspace, and skips bad entries; setup.sh excludes them
 0.8.0 05d4c954a946 workspaces are named by their folders' short names and leaf, joined by dots (.delphi/names.sh, short-name files; ws/s.app.argos.argos-dev, was ws/software/…/argos-dev); workspaces: entries are - <name> | - main, copied to linked/<name>; sync carries ws/<old> over once (migration)
 0.9.0 b850821eaa9a linked/<name> are full clones on ws/<name> (or main) tracking origin, pushes allowed; setup.sh switches each back to its branch if switched away and pulls it (migration)
+1.0.0 44693a895995 1.0: workspaces: clones live at workspaces/<name> (was linked/<name>; DELPHI_WORKSPACES, was DELPHI_LINKED); setup.sh also runs each one's own setup.sh, and a workspace inside another's workspaces/ skips its own workspaces: (migration)

From bfb6e012264ab375563afed4a0c2262d2fa406cf Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 18 Oct 2026 18:37:43 +0000
Subject: [PATCH 09/19] delphi: sync inherited files from main

---
 .claude/skills/setup-workspace/SKILL.md  | 6 +++---
 .claude/skills/switch-workspace/SKILL.md | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.claude/skills/setup-workspace/SKILL.md b/.claude/skills/setup-workspace/SKILL.md
index 795e46a..fdc1ce8 100644
--- a/.claude/skills/setup-workspace/SKILL.md
+++ b/.claude/skills/setup-workspace/SKILL.md
@@ -11,8 +11,8 @@ Run from the workspace root after any change, and to refresh references and work
 bash .delphi/setup.sh
 ```
 
-- The clones under `linked/` are full clones, each on its branch (`ws/<name>` or `main`) tracking origin, for reading: don't edit, branch, or push them from this workspace. Each setup run switches a clone back to its branch if it was switched away (refused while it has uncommitted changes) and pulls it. To change one of those workspaces or main, work in its own clone or switch to it (`switch-workspace` skill).
-- This workspace's project folder (shared context, `AUTHORING.md`, `workspace-defaults/`) is the folder above `workspaces/<leaf>/` in `linked/main/` (`bash .delphi/switch.sh --list` prints it): for `s.app.argos.argos-dev`, `linked/main/software/application-software/argos/`. List workspaces and their project folders: `bash .delphi/switch.sh --list`.
+- The clones under `workspaces/` are full clones, each on its branch (`ws/<name>` or `main`) tracking origin, for reading: don't edit, branch, or push them from this workspace. Each setup run switches a clone back to its branch if it was switched away (refused while it has uncommitted changes), pulls it, and runs its own setup, so that workspace's repos and references are under it too (it skips its own `workspaces:`, so they don't chain). To change one of those workspaces or main, work in its own clone or switch to it (`switch-workspace` skill).
+- This workspace's project folder (shared context, `AUTHORING.md`, `workspace-defaults/`) is the folder above `workspaces/<leaf>/` in `workspaces/main/` (`bash .delphi/switch.sh --list` prints it): for `s.app.argos.argos-dev`, `workspaces/main/software/application-software/argos/`. List workspaces and their project folders: `bash .delphi/switch.sh --list`.
 - `workspace.yml` is shared: change it on a branch and open a PR into `ws/<this-name>` (the `name:` in `workspace.yml`). For a one-off look, add the entry, run setup, then `git restore workspace.yml`.
-- Setup never deletes what you'd lose. A removed entry's `linked/<name>/`, `references/<name>/`, or repo store and worktrees stay until you delete them (ask first).
+- Setup never deletes what you'd lose. A removed entry's `workspaces/<name>/`, `references/<name>/`, or repo store and worktrees stay until you delete them (ask first).
 - When Delphi releases a version that needs cleanup in clones, setup runs its migration first (`.delphi/migrations/`), once per workspace. A migration removes only what nothing is lost from, and otherwise stops setup with what to do: tell the user, do it with their go-ahead, and re-run.
diff --git a/.claude/skills/switch-workspace/SKILL.md b/.claude/skills/switch-workspace/SKILL.md
index a29a5df..e0a8b42 100644
--- a/.claude/skills/switch-workspace/SKILL.md
+++ b/.claude/skills/switch-workspace/SKILL.md
@@ -13,7 +13,7 @@ bash .delphi/switch.sh main          # Delphi's main: project folders, templates
 - The user can also switch from the `/ws-delphi` pane (the `delphi` plugin's mod), which shows them as cards (`bash .delphi/switch.sh --list`): press one, then Switch workspace; `/ws-delphi <name>` switches straight away, and `/ws-delphi --web` opens the same cards in a browser tab.
 - List workspaces and their project folders: `bash .delphi/switch.sh --list`.
 - It refuses while tracked files have changes: commit them on a branch (and PR them) first. Then it fetches, switches, fast-forwards, and runs the new workspace's `.delphi/setup.sh`.
-- The post-checkout hook parks this workspace's `repos/`, `worktrees/`, `references/` and `linked/` in `.delphi/parked/<name>/` (git-ignored; `<name>` as in its `workspace.yml`) and brings the other's back at the same paths, so worktrees and the work in them return as they were. Switch back the same way. Never run `git clean -X` or `git stash --all` at the workspace root: they take ignored files, parked work included.
+- The post-checkout hook parks this workspace's `repos/`, `worktrees/`, `references/` and `workspaces/` in `.delphi/parked/<name>/` (git-ignored; `<name>` as in its `workspace.yml`) and brings the other's back at the same paths, so worktrees and the work in them return as they were. Switch back the same way. Never run `git clean -X` or `git stash --all` at the workspace root: they take ignored files, parked work included.
 - Before switching, stop anything running from `worktrees/` (dev servers, Docker builds): its folder moves.
 - No restart needed: skills under `.claude/skills/` reload on their own, and the `delphi` mod sends the new workspace's `CLAUDE.md` with the next prompt. Without the mod installed, this session keeps the old `CLAUDE.md`: tell the user to restart Claude Code in the same folder before starting work in the new workspace.
 - To change the workspace you switched to: `git switch -c <branch>`, commit, push, and open a PR into `ws/<name>` (or `main`).

From 5abbfc6cfd3b91b01cf36ad17f5fd0fc73b32302 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 18 Oct 2026 23:52:03 +0000
Subject: [PATCH 10/19] delphi: sync .delphi/ from main

---
 .delphi/manifest.yml    |  2 +-
 .delphi/new-worktree.sh |  2 +-
 .delphi/paths.sh        |  2 +-
 .delphi/setup.sh        | 25 ++++---------------------
 .delphi/versions        |  1 +
 5 files changed, 8 insertions(+), 24 deletions(-)

diff --git a/.delphi/manifest.yml b/.delphi/manifest.yml
index dc3beb2..6718697 100644
--- a/.delphi/manifest.yml
+++ b/.delphi/manifest.yml
@@ -6,7 +6,7 @@
 #   MINOR  something new that existing clones need nothing for
 #   MAJOR  clones need cleanup (MINOR while 0.x): add .delphi/migrations/<version>-<slug>.sh, which
 #          setup.sh runs once per workspace in each clone (rules in Delphi's CLAUDE.md)
-version: 1.0.0
+version: 1.1.0
 files:                        # repo-relative paths; a trailing / means everything under it
   - .delphi/manifest.yml
   - .delphi/.gitattributes
diff --git a/.delphi/new-worktree.sh b/.delphi/new-worktree.sh
index 7760f90..04c3713 100755
--- a/.delphi/new-worktree.sh
+++ b/.delphi/new-worktree.sh
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # .delphi/new-worktree.sh <repo> <branch> [<base>]: create or reuse worktrees/<repo>/<branch> from
-# the store .delphi/setup.sh made at repos/<repo>, and print its path. An existing branch
+# the clone .delphi/setup.sh made at repos/<repo>, and print its path. An existing branch
 # (local or on origin) is checked out; a new one starts from <base> (default: origin's default
 # branch). Runs on bash 3.2 and Git Bash.
 set -euo pipefail
diff --git a/.delphi/paths.sh b/.delphi/paths.sh
index 327d6c8..b8ef606 100644
--- a/.delphi/paths.sh
+++ b/.delphi/paths.sh
@@ -6,7 +6,7 @@
 # Bash and zsh safe.
 # shellcheck shell=bash
 DELPHI_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
-DELPHI_REPOS=$DELPHI_ROOT/repos               # bare stores: repos/<repo>
+DELPHI_REPOS=$DELPHI_ROOT/repos               # clones: repos/<repo>
 DELPHI_WORKTREES=$DELPHI_ROOT/worktrees       # checkouts: worktrees/<repo>/<branch>
 DELPHI_REFERENCES=$DELPHI_ROOT/references     # read-only dependency sources: references/<name>
 DELPHI_WORKSPACES=$DELPHI_ROOT/workspaces     # Delphi clones to read: workspaces/<workspace>, workspaces/main
diff --git a/.delphi/setup.sh b/.delphi/setup.sh
index 0e7f3af..dc0ff21 100755
--- a/.delphi/setup.sh
+++ b/.delphi/setup.sh
@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 # .delphi/setup.sh: run in a checkout of ws/<name> (the workspace root; .delphi/ comes from Delphi's
 # main, which sync keeps on every ws/* branch, so edit it only there; on main this does nothing). For each repo listed under
-# `repos:` in workspace.yml, fetches it into a bare store at repos/<name> (unless present) and checks
-# out its default branch as the first worktree, worktrees/<name>/<default-branch>. For each repo under
+# `repos:` in workspace.yml, clones it at repos/<name> (unless present), on its default branch, and
+# adds nothing else (.delphi/new-worktree.sh makes worktrees from it). For each repo under
 # `references-git:` (read-only dependency sources, `<name>: <git-url> [<ref>]`), checks out a shallow,
 # detached copy of <ref> (default: origin's default branch) at references/<name>, refreshed on every
 # run, with pushes disabled. Each entry under `workspaces:` (`- <name>`, a workspace's dotted name
@@ -99,25 +99,8 @@ while read -r kind name url ref; do
   if [ "$kind" = link ]; then [ -n "$inside" ] || link "$name"; continue; fi
   case "$name" in . | .. | *[!A-Za-z0-9._-]*) echo "setup: skipping unsafe repo name '$name'" >&2 && continue ;; esac
   if [ "$kind" = ref ]; then readonly_copy "references/$name" "$url" ${ref:+"$ref"} && continue; fi
-  store=repos/$name
-  if [ -e "$store" ]; then
-    echo "repos/$name: already present"
-  else
-    git init -q --bare "$store"
-    git -C "$store" remote add origin "$url"
-    git -C "$store" fetch -q origin </dev/null
-    git -C "$store" remote set-head origin -a >/dev/null </dev/null
-  fi
-  def=$(git -C "$store" symbolic-ref -q --short refs/remotes/origin/HEAD) ||
-    { echo "setup: repos/$name has no origin/HEAD; skipping its worktree" >&2 && continue; }
-  def=${def#origin/}
-  dest=worktrees/$name/$def
-  if [ -e "$dest" ]; then continue
-  elif git -C "$store" rev-parse -q --verify "refs/heads/$def" >/dev/null; then
-    git -C "$store" worktree add -q "$PWD/$dest" "$def" ||
-      echo "setup: could not check out $dest (is $def checked out in repos/$name?)" >&2
-  else
-    git -C "$store" worktree add -q --track -b "$def" "$PWD/$dest" "origin/$def"
+  if [ -e "repos/$name" ]; then echo "repos/$name: already present"
+  else git clone -q "$url" "repos/$name" </dev/null || echo "setup: could not clone $url into repos/$name" >&2
   fi
 done <<EOF2
 $list
diff --git a/.delphi/versions b/.delphi/versions
index 36f014b..ebb33ed 100644
--- a/.delphi/versions
+++ b/.delphi/versions
@@ -15,3 +15,4 @@
 0.8.0 05d4c954a946 workspaces are named by their folders' short names and leaf, joined by dots (.delphi/names.sh, short-name files; ws/s.app.argos.argos-dev, was ws/software/…/argos-dev); workspaces: entries are - <name> | - main, copied to linked/<name>; sync carries ws/<old> over once (migration)
 0.9.0 b850821eaa9a linked/<name> are full clones on ws/<name> (or main) tracking origin, pushes allowed; setup.sh switches each back to its branch if switched away and pulls it (migration)
 1.0.0 44693a895995 1.0: workspaces: clones live at workspaces/<name> (was linked/<name>; DELPHI_WORKSPACES, was DELPHI_LINKED); setup.sh also runs each one's own setup.sh, and a workspace inside another's workspaces/ skips its own workspaces: (migration)
+1.1.0 a3446f7f763c setup.sh clones each repos: entry at repos/<name> (a normal clone on its default branch, was a bare store) and adds no worktree; new-worktree.sh makes worktrees from that clone; older bare stores are left as they are

From 297969ed2886e98d03e97e643b8a8b6ab54b96df Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 18 Oct 2026 23:52:04 +0000
Subject: [PATCH 11/19] delphi: sync inherited files from main

---
 .claude/skills/new-worktree/SKILL.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.claude/skills/new-worktree/SKILL.md b/.claude/skills/new-worktree/SKILL.md
index 9fd3ac7..9ee9e83 100644
--- a/.claude/skills/new-worktree/SKILL.md
+++ b/.claude/skills/new-worktree/SKILL.md
@@ -10,6 +10,5 @@ bash .delphi/new-worktree.sh <repo> <branch> [<base>]
 ```
 
 - An existing branch (local or on origin, e.g. a PR head) is checked out; anything else is created from `<base>` (default: the repo's default branch). Safe to re-run.
-- Stay at the workspace root and reach into the worktree by the printed path. Never switch branches in an existing worktree or work in the bare store `repos/<repo>`.
-- Keep `worktrees/<repo>/<default-branch>/` a clean reference: fetch and fast-forward only.
+- Stay at the workspace root and reach into the worktree by the printed path. Never switch branches in an existing worktree or work in the clone `repos/<repo>` (it's for people working on one thing at a time).
 - After the branch merges: `git -C repos/<repo> worktree remove ../../worktrees/<repo>/<branch>`.

From 7a915b5140047dcc4e6cb46c94e1d0fbd3a6d716 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 00:04:12 +0000
Subject: [PATCH 12/19] delphi: sync inherited files from main

---
 .claude/skills/run-local/SKILL.md            |  2 +-
 .claude/skills/run-local/scripts/serve.sh    | 11 ++++--
 .claude/skills/verify-graph/SKILL.md         |  4 ++-
 .claude/skills/verify-graph/scripts/check.js |  1 +
 .claude/skills/verify-graph/scripts/perf.js  | 38 ++++++++++++++++++++
 .claude/skills/verify-graph/scripts/perf.sh  | 19 ++++++++++
 6 files changed, 71 insertions(+), 4 deletions(-)
 create mode 100644 .claude/skills/verify-graph/scripts/perf.js
 create mode 100755 .claude/skills/verify-graph/scripts/perf.sh

diff --git a/.claude/skills/run-local/SKILL.md b/.claude/skills/run-local/SKILL.md
index 8618099..7acb908 100644
--- a/.claude/skills/run-local/SKILL.md
+++ b/.claude/skills/run-local/SKILL.md
@@ -11,4 +11,4 @@ bash scripts/run-local.sh <branch>...
 
 It starts the backend if it's down (`client-dev`, or `scylla-dev` plus `cargo run` when a target changes `scylla-server/`), and serves each target's client on the next free port; parallel runs (one per session or agent) each get their own. With no branches it reports what's running.
 
-Report each branch's client URL and the backend. A failed compile or a stale-backend warning is a finding: show it to the user. Stop a client with `kill <pid>` from its line.
+Report each branch's client URL and the backend. A failed compile or a stale-backend warning is a finding: show it to the user. Stop a client with `kill <pid>` from its line. When every port is taken it lists what holds each; clients from other checkouts are the user's, so ask before stopping them.
diff --git a/.claude/skills/run-local/scripts/serve.sh b/.claude/skills/run-local/scripts/serve.sh
index 99d5095..d8de89c 100755
--- a/.claude/skills/run-local/scripts/serve.sh
+++ b/.claude/skills/run-local/scripts/serve.sh
@@ -3,7 +3,7 @@
 # port in 4200-4210, in the background, and print `<branch> client=<url> pid=<pid> log=<file>` once
 # it has compiled. Re-running for a worktree that is still being served prints its existing client.
 # Runs `npm ci` first if node_modules lacks ng (missing or half-installed). Exits 1, with the log's
-# tail, if the build fails.
+# tail, if the build fails, or with what holds each port if none is free.
 set -euo pipefail
 wt=$(cd "${1:?usage: serve.sh <argos-worktree>}" && pwd)
 branch=$(git -C "$wt" rev-parse --abbrev-ref HEAD)
@@ -27,7 +27,14 @@ trap 'rmdir "$lock" 2>/dev/null || true' EXIT
 claimed() { for f in "$state"/*.port; do [ -f "$f" ] && [ "$(cat "$f")" = "$1" ] && kill -0 "$(cat "${f%.port}.pid")" 2>/dev/null && return; done; return 1; }
 port=
 for p in $(seq 4200 4210); do up "$p" || claimed "$p" || { port=$p && break; }; done
-[ -n "$port" ] || { echo "serve: no free port in 4200-4210" >&2 && exit 1; }
+# Name what holds each port, so a stale client from another checkout can be stopped (lsof, where there is one).
+holders() {
+  for p in $(seq 4200 4210); do
+    pid=$(lsof -nP -iTCP:"$p" -sTCP:LISTEN -t 2>/dev/null | head -1) || true
+    if [ -n "$pid" ]; then echo "  $p pid=$pid $(lsof -a -p "$pid" -d cwd -Fn 2>/dev/null | sed -n 's/^n//p')"; fi
+  done
+}
+[ -n "$port" ] || { echo "serve: no free port in 4200-4210, held by:" >&2 && holders >&2 && exit 1; }
 echo $$ >"$key.pid" && echo "$port" >"$key.port" # claimed by this script until ng serve's pid replaces it
 rmdir "$lock" && trap - EXIT
 
diff --git a/.claude/skills/verify-graph/SKILL.md b/.claude/skills/verify-graph/SKILL.md
index 64167c9..ae99371 100644
--- a/.claude/skills/verify-graph/SKILL.md
+++ b/.claude/skills/verify-graph/SKILL.md
@@ -4,7 +4,7 @@ description: Playwright CLI verification of the graph page — modes, controls,
 user-invocable: true
 ---
 
-Get the branch's client running with `run-local <branch>`; its URL is `BASE_URL`. Then run the base checks:
+Get the branch's client running with `run-local <branch>`; its URL is `BASE_URL`. The scripts need `playwright-cli` (`npm i -g @playwright/cli`, then `playwright-cli install-browser chromium`; cloud containers use their preinstalled Chromium). Then run the base checks:
 
 ```
 bash scripts/check.sh <branch> "$BASE_URL"
@@ -19,4 +19,6 @@ Go further where the diff points, by hand in the same session (`P="playwright-cl
 - The seeded run: click Select Run, then `bash scripts/select-run.sh <branch> $(bash scripts/seed.sh)`.
 - Screenshots: `$P screenshot --filename=pictures/<branch>/verify-graph/NN-<name>.png` (gitignored).
 
+When the diff touches rendering or the live data path, measure it too: `bash scripts/perf.sh <branch> "$BASE_URL" [<topic>,…]` prints retained JS heap, allocation rate, frame rate and long tasks (`scripts/perf.js`), then the browser's GPU-process memory, where a WebGL chart's buffers show up. The numbers drift with machine load, so run the branch and its base side by side, twice, at the same topics. Calypso sends about one point a second per topic and has no rate setting, so the chart's own data is small next to the app's: a JS-heap gap of a few MB is noise, and more topics widen real ones.
+
 When a hand check keeps coming back, add it to `check.js`. Report `check.sh`'s lines plus one line per hand check, and the screenshot folder. `$P close` at the end.
diff --git a/.claude/skills/verify-graph/scripts/check.js b/.claude/skills/verify-graph/scripts/check.js
index bd1e8b0..3fcb734 100644
--- a/.claude/skills/verify-graph/scripts/check.js
+++ b/.claude/skills/verify-graph/scripts/check.js
@@ -61,6 +61,7 @@ async (page) => {
     await button('Realtime').click();
     await text('Real Time').waitFor({ timeout: 5000 });
     await page.getByRole('combobox', { name: 'Quick Select' }).click();
+    await page.getByRole('option').first().waitFor({ timeout: 5000 });
     const options = await page.getByRole('option').count();
     if (options !== 11) throw new Error(`${options} Quick Select options, not 11`);
     await page.getByRole('option', { name: '5 minutes', exact: true }).click();
diff --git a/.claude/skills/verify-graph/scripts/perf.js b/.claude/skills/verify-graph/scripts/perf.js
new file mode 100644
index 0000000..404ac25
--- /dev/null
+++ b/.claude/skills/verify-graph/scripts/perf.js
@@ -0,0 +1,38 @@
+async (page) => {
+  // Live-mode cost of the graph page with __TOPICS__ selected: retained JS heap after a GC, how fast it allocates
+  // (heap growth between 100 ms samples, GC drops ignored), and frame rate. Compare branches at the same topics.
+  const topics = '__TOPICS__'.split(',');
+  await page.goto(`__URL__/graph?topics=${encodeURIComponent(topics.join(','))}`);
+  await page.getByText('Real Time').first().waitFor({ timeout: 30000 });
+  const cdp = await page.context().newCDPSession(page);
+  const heap = async (gc) => {
+    if (gc) await cdp.send('HeapProfiler.collectGarbage');
+    return (await cdp.send('Runtime.getHeapUsage')).usedSize / 1e6;
+  };
+  await page.waitForTimeout(20000); // fill the live window
+  let alloc = 0, prev = await heap(false);
+  const t0 = Date.now();
+  while (Date.now() - t0 < 20000) {
+    await page.waitForTimeout(100);
+    const h = await heap(false);
+    if (h > prev) alloc += h - prev;
+    prev = h;
+  }
+  const allocMBps = alloc / ((Date.now() - t0) / 1000);
+  const frames = await page.evaluate(() => new Promise((done) => {
+    let n = 0, worst = 0, longTasks = 0, last = performance.now();
+    const end = last + 10000;
+    new PerformanceObserver((l) => (longTasks += l.getEntries().length)).observe({ type: 'longtask' });
+    const tick = (t) => {
+      worst = Math.max(worst, t - last);
+      last = t;
+      n++;
+      if (t < end) requestAnimationFrame(tick);
+      else done({ fps: n / 10, worstFrameMs: Math.round(worst), longTasks });
+    };
+    requestAnimationFrame(tick);
+  }));
+  const retainedMB = await heap(true);
+  return `retained JS heap ${retainedMB.toFixed(1)} MB, allocating ${allocMBps.toFixed(1)} MB/s, ` +
+    `${frames.fps} fps, worst frame ${frames.worstFrameMs} ms, ${frames.longTasks} long tasks`;
+}
diff --git a/.claude/skills/verify-graph/scripts/perf.sh b/.claude/skills/verify-graph/scripts/perf.sh
new file mode 100755
index 0000000..2218f42
--- /dev/null
+++ b/.claude/skills/verify-graph/scripts/perf.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# perf.sh <branch> <base-url> [<topic>,…]: measure the graph page live in <branch>'s playwright-cli session
+# (perf.js: JS heap, allocation rate, frames; about a minute), then its browser's GPU-process memory, where
+# a WebGL chart's buffers show up. Default topics: four BMS ones. Numbers are relative: compare branches.
+set -euo pipefail
+here=$(cd "$(dirname "$0")" && pwd)
+branch=${1:?usage: perf.sh <branch> <base-url> [<topic>,…]}; url=${2:?usage: perf.sh <branch> <base-url> [<topic>,…]}; url=${url%/}
+topics=${3:-BMS/Segment_Total_Volt/0,BMS/PerCell/Alpha/3/Volts/5,BMS/PerCell/Alpha/3/Volts/4,BMS/PerCell/Alpha/4/Therms/0}
+playwright-cli list | grep -q "^- $branch:" || bash "$here/open.sh" "$branch" "$url/graph" >/dev/null
+code=$(sed -e "s|__URL__|$url|; s|__TOPICS__|$topics|g" "$here/perf.js")
+playwright-cli -s="$branch" --raw run-code "$code" | node -e 'process.stdout.write(JSON.parse(require("fs").readFileSync(0, "utf8")) + "\n")'
+# The session's daemon runs its browser; the browser's --type=gpu-process child holds GPU memory.
+ps -axo pid=,ppid=,rss=,command= | awk -v s=" $branch " '
+  { pid[NR] = $1; ppid[NR] = $2; rss[NR] = $3; cmd[NR] = $0 }
+  index($0, "cliDaemon") && index($0 " ", s) { daemon[$1] = 1 }
+  END {
+    for (i = 1; i <= NR; i++) if (daemon[ppid[i]]) browser[pid[i]] = 1
+    for (i = 1; i <= NR; i++) if (browser[ppid[i]] && index(cmd[i], "--type=gpu-process")) printf "GPU process %d MB\n", rss[i] / 1024
+  }'

From 17c5eb1f308e2575526b4c0d3f98602c562a2fd2 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 00:05:29 +0000
Subject: [PATCH 13/19] delphi: sync inherited files from main

---
 .claude/skills/open-pr/SKILL.md   | 7 ++++---
 .claude/skills/update-pr/SKILL.md | 2 +-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/.claude/skills/open-pr/SKILL.md b/.claude/skills/open-pr/SKILL.md
index d2b9bf6..b1e7c71 100644
--- a/.claude/skills/open-pr/SKILL.md
+++ b/.claude/skills/open-pr/SKILL.md
@@ -6,8 +6,9 @@ description: Run pre-PR checks, push the branch, and open a draft pull request o
 First load the project's `pr-conventions` skill (inherited from the project's `workspace-inherit/`) for its base branch, commit format, checks, labels, and screenshots.
 
 1. **Check:** `bash scripts/pr-checks.sh <repo> <branch> origin/<base> '<commit format>'` (clean tree, commit subjects match the project's format, merges cleanly into the base), then the project's own checks. Stop and fix on any FAIL.
-2. **Open:** push (`git -C worktrees/<repo>/<branch> push -u origin <branch>`), then run `(cd worktrees/<repo>/<branch> && gh pr create --draft --base <base> --head <branch> --title "<title>" --body-file /tmp/<branch>-pr-body.md --assignee @me)` with the project's labels (`--label`), and report the URL.
-3. **Spike:** the PR stays a draft; getting it merged isn't the goal. Once it's checked and working, run `report-spike`.
+2. **Media:** if the diff touches the UI, ask the user whether to add screenshots to the PR, listing any already in the project's screenshot folder for this branch so they can pick those instead of new ones; on no, skip this step. For new ones, use the project's UI QA to take Playwright screenshots of the changed views into its screenshot folder, or, when the change adds or changes an animation, record a short video instead (a browser context with `recordVideo: { dir }` saves a `.webm` when it closes). Images must be under 10 MB; video under 10 MB on a Free plan, 100 MB on a paid one.
+3. **Open:** push (`git -C worktrees/<repo>/<branch> push -u origin <branch>`), then run `(cd worktrees/<repo>/<branch> && gh pr create --draft --base <base> --head <branch> --title "<title>" --body-file /tmp/<branch>-pr-body.md --assignee @me)` with the project's labels (`--label`) and one `--attach <file>` per screenshot or video, and report the URL.
+4. **Spike:** the PR stays a draft; getting it merged isn't the goal. Once it's checked and working, run `report-spike`.
 
 ## PR body
 
@@ -18,4 +19,4 @@ Fill the worktree's `.github/pull_request_template.md` from the diff, following
 - Delete the template's comments and any optional or non-applicable sections, and check off the Checklist.
 - At most three backtick uses in the body.
 - End with `Closes #{ticket}` (the branch's leading number), or `Spike for #{ticket}` on a spike, which its PR never closes.
-- UI changes: put `_screenshot pending_` and remind the user to drag-drop the shots from the project's screenshot folder. Never commit screenshots.
+- Screenshots and videos: reference each one by its path from the worktree, `![<what it shows>](<path>)`; `--attach` uploads it and rewrites the reference to its `user-attachments` URL. `--attach` needs gh v2.99.0+: if `gh pr create --help` doesn't list it, put `_screenshot pending_` instead and remind the user to drag-drop the files from the screenshot folder. Never commit screenshots or videos.
diff --git a/.claude/skills/update-pr/SKILL.md b/.claude/skills/update-pr/SKILL.md
index 3664f3a..069b517 100644
--- a/.claude/skills/update-pr/SKILL.md
+++ b/.claude/skills/update-pr/SKILL.md
@@ -3,4 +3,4 @@ name: update-pr
 description: Update a branch's PR description to reflect the latest changes
 ---
 
-Load the project's `pr-conventions` skill, then rewrite the branch's PR body (`(cd worktrees/<repo>/<branch> && gh pr view)`) to match `git -C worktrees/<repo>/<branch> diff origin/<base>...HEAD`, following the PR body rules in the `open-pr` skill. Keep human-written text that's still accurate, `user-attachments` screenshots, and `Closes`/`Fixes` refs. Write it to `/tmp/<branch>-pr-body.md`, apply it with `gh pr edit <branch> --body-file` from the worktree, and add any of the project's labels that are missing with `--add-label`.
+Load the project's `pr-conventions` skill, then rewrite the branch's PR body (`(cd worktrees/<repo>/<branch> && gh pr view)`) to match `git -C worktrees/<repo>/<branch> diff origin/<base>...HEAD`, following the PR body rules in the `open-pr` skill. Keep human-written text that's still accurate, `user-attachments` screenshots, and `Closes`/`Fixes` refs; new screenshots or videos follow open-pr's media step, attached with `gh pr edit --attach`. Write it to `/tmp/<branch>-pr-body.md`, apply it with `gh pr edit <branch> --body-file` from the worktree, and add any of the project's labels that are missing with `--add-label`.

From 4c4ae103ae66ddd08f062c5cd1ce6e7e4c12941c Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 00:26:34 +0000
Subject: [PATCH 14/19] delphi: sync .delphi/ from main

---
 .delphi/manifest.yml    |  2 +-
 .delphi/new-worktree.sh | 13 +++++++------
 .delphi/paths.sh        |  2 +-
 .delphi/setup.sh        | 23 +++++++++++++++++++++--
 .delphi/versions        |  1 +
 5 files changed, 31 insertions(+), 10 deletions(-)

diff --git a/.delphi/manifest.yml b/.delphi/manifest.yml
index 6718697..8546a04 100644
--- a/.delphi/manifest.yml
+++ b/.delphi/manifest.yml
@@ -6,7 +6,7 @@
 #   MINOR  something new that existing clones need nothing for
 #   MAJOR  clones need cleanup (MINOR while 0.x): add .delphi/migrations/<version>-<slug>.sh, which
 #          setup.sh runs once per workspace in each clone (rules in Delphi's CLAUDE.md)
-version: 1.1.0
+version: 1.2.0
 files:                        # repo-relative paths; a trailing / means everything under it
   - .delphi/manifest.yml
   - .delphi/.gitattributes
diff --git a/.delphi/new-worktree.sh b/.delphi/new-worktree.sh
index 04c3713..6e53461 100755
--- a/.delphi/new-worktree.sh
+++ b/.delphi/new-worktree.sh
@@ -1,16 +1,17 @@
 #!/usr/bin/env bash
 # .delphi/new-worktree.sh <repo> <branch> [<base>]: create or reuse worktrees/<repo>/<branch> from
-# the clone .delphi/setup.sh made at repos/<repo>, and print its path. An existing branch
-# (local or on origin) is checked out; a new one starts from <base> (default: origin's default
-# branch). Runs on bash 3.2 and Git Bash.
+# the bare store .delphi/setup.sh made at worktrees/<repo>/.bare (never the clone at repos/<repo>), and
+# print its path. An existing branch (local or on origin) is checked out; a new one starts from <base>
+# (default: origin's default branch). Runs on bash 3.2 and Git Bash.
 set -euo pipefail
 # shellcheck source-path=SCRIPTDIR source=paths.sh
 . "$(dirname "$0")/paths.sh"
 repo=${1:?usage: new-worktree.sh <repo> <branch> [<base>]} branch=${2:?usage: new-worktree.sh <repo> <branch> [<base>]}
 base=${3:-origin/HEAD} dest="$DELPHI_WORKTREES/$repo/$branch"
-g() { git -C "$DELPHI_REPOS/$repo" "$@"; }
-[ -d "$DELPHI_REPOS/$repo" ] ||
-  { echo "new-worktree: no repos/$repo (list it under repos: and run .delphi/setup.sh; references are read-only)" >&2 && exit 1; }
+store=$DELPHI_WORKTREES/$repo/.bare
+g() { git -C "$store" "$@"; }
+[ -d "$store" ] ||
+  { echo "new-worktree: no worktrees/$repo/.bare (list it under repos: and run .delphi/setup.sh; references are read-only)" >&2 && exit 1; }
 g fetch -q origin
 if [ -d "$dest" ]; then :
 elif g rev-parse -q --verify "refs/heads/$branch" >/dev/null; then
diff --git a/.delphi/paths.sh b/.delphi/paths.sh
index b8ef606..f5961cd 100644
--- a/.delphi/paths.sh
+++ b/.delphi/paths.sh
@@ -7,7 +7,7 @@
 # shellcheck shell=bash
 DELPHI_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
 DELPHI_REPOS=$DELPHI_ROOT/repos               # clones: repos/<repo>
-DELPHI_WORKTREES=$DELPHI_ROOT/worktrees       # checkouts: worktrees/<repo>/<branch>
+DELPHI_WORKTREES=$DELPHI_ROOT/worktrees       # checkouts: worktrees/<repo>/<branch>, from the bare store worktrees/<repo>/.bare
 DELPHI_REFERENCES=$DELPHI_ROOT/references     # read-only dependency sources: references/<name>
 DELPHI_WORKSPACES=$DELPHI_ROOT/workspaces     # Delphi clones to read: workspaces/<workspace>, workspaces/main
 export DELPHI_ROOT DELPHI_REPOS DELPHI_WORKTREES DELPHI_REFERENCES DELPHI_WORKSPACES
diff --git a/.delphi/setup.sh b/.delphi/setup.sh
index dc0ff21..7abe7ea 100755
--- a/.delphi/setup.sh
+++ b/.delphi/setup.sh
@@ -1,8 +1,10 @@
 #!/usr/bin/env bash
 # .delphi/setup.sh: run in a checkout of ws/<name> (the workspace root; .delphi/ comes from Delphi's
 # main, which sync keeps on every ws/* branch, so edit it only there; on main this does nothing). For each repo listed under
-# `repos:` in workspace.yml, clones it at repos/<name> (unless present), on its default branch, and
-# adds nothing else (.delphi/new-worktree.sh makes worktrees from it). For each repo under
+# `repos:` in workspace.yml, clones it at repos/<name> (unless present). Separately, fetches it into a
+# bare store at worktrees/<name>/.bare (unless present) and checks out its default branch as the first
+# worktree, worktrees/<name>/<default-branch> (re-created if missing); .delphi/new-worktree.sh makes the
+# others from that store, so worktrees never touch the clone. For each repo under
 # `references-git:` (read-only dependency sources, `<name>: <git-url> [<ref>]`), checks out a shallow,
 # detached copy of <ref> (default: origin's default branch) at references/<name>, refreshed on every
 # run, with pushes disabled. Each entry under `workspaces:` (`- <name>`, a workspace's dotted name
@@ -102,6 +104,23 @@ while read -r kind name url ref; do
   if [ -e "repos/$name" ]; then echo "repos/$name: already present"
   else git clone -q "$url" "repos/$name" </dev/null || echo "setup: could not clone $url into repos/$name" >&2
   fi
+  store=worktrees/$name/.bare
+  if [ ! -e "$store" ]; then
+    git init -q --bare "$store"
+    git -C "$store" remote add origin "$url"
+    git -C "$store" fetch -q origin </dev/null
+    git -C "$store" remote set-head origin -a >/dev/null </dev/null
+  fi
+  def=$(git -C "$store" symbolic-ref -q --short refs/remotes/origin/HEAD) ||
+    { echo "setup: $store has no origin/HEAD; skipping its worktree" >&2 && continue; }
+  def=${def#origin/}
+  dest=worktrees/$name/$def
+  if [ -e "$dest" ]; then continue
+  elif git -C "$store" rev-parse -q --verify "refs/heads/$def" >/dev/null; then
+    git -C "$store" worktree add -q "$PWD/$dest" "$def" || echo "setup: could not check out $dest" >&2
+  else
+    git -C "$store" worktree add -q --track -b "$def" "$PWD/$dest" "origin/$def"
+  fi
 done <<EOF2
 $list
 EOF2
diff --git a/.delphi/versions b/.delphi/versions
index ebb33ed..2fa678d 100644
--- a/.delphi/versions
+++ b/.delphi/versions
@@ -16,3 +16,4 @@
 0.9.0 b850821eaa9a linked/<name> are full clones on ws/<name> (or main) tracking origin, pushes allowed; setup.sh switches each back to its branch if switched away and pulls it (migration)
 1.0.0 44693a895995 1.0: workspaces: clones live at workspaces/<name> (was linked/<name>; DELPHI_WORKSPACES, was DELPHI_LINKED); setup.sh also runs each one's own setup.sh, and a workspace inside another's workspaces/ skips its own workspaces: (migration)
 1.1.0 a3446f7f763c setup.sh clones each repos: entry at repos/<name> (a normal clone on its default branch, was a bare store) and adds no worktree; new-worktree.sh makes worktrees from that clone; older bare stores are left as they are
+1.2.0 d139aaf9f4a5 worktrees come from their own bare store, worktrees/<name>/.bare, separate from the plain clone at repos/<name>; setup.sh makes the store and the default-branch worktree again; an older bare store at repos/<name> is left as it is

From 47a188fab9d56782d249fc1aad1c110ebfde27bd Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 00:26:34 +0000
Subject: [PATCH 15/19] delphi: sync inherited files from main

---
 .claude/skills/address-pr-comments/scripts/fetch-feedback.sh | 2 +-
 .claude/skills/new-worktree/SKILL.md                         | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/.claude/skills/address-pr-comments/scripts/fetch-feedback.sh b/.claude/skills/address-pr-comments/scripts/fetch-feedback.sh
index 1debe03..ce1efd9 100755
--- a/.claude/skills/address-pr-comments/scripts/fetch-feedback.sh
+++ b/.claude/skills/address-pr-comments/scripts/fetch-feedback.sh
@@ -13,7 +13,7 @@ usage="usage: fetch-feedback.sh [--all] <repo> <pr-number>|<branch>"
 repo=${1:?$usage} ref=${2:?$usage}
 # shellcheck source=/dev/null
 . "${DELPHI_ROOT:?unset: start the session at the workspace root, on Delphi 0.2.0+ (pull its ws/ branch), or source <root>/.delphi/paths.sh}/.delphi/paths.sh"
-gh_init fetch-feedback "$DELPHI_REPOS/$repo"
+gh_init fetch-feedback "$DELPHI_WORKTREES/$repo/.bare"
 
 case "$ref" in *[!0-9]*) get "repos/$SLUG/pulls?state=all&head=${SLUG%%/*}:$ref" | jq '.[0] // error("no PR")' ;;
   *) get "repos/$SLUG/pulls/$ref" ;; esac >"$TMP/pr"
diff --git a/.claude/skills/new-worktree/SKILL.md b/.claude/skills/new-worktree/SKILL.md
index 9ee9e83..0520aa7 100644
--- a/.claude/skills/new-worktree/SKILL.md
+++ b/.claude/skills/new-worktree/SKILL.md
@@ -10,5 +10,6 @@ bash .delphi/new-worktree.sh <repo> <branch> [<base>]
 ```
 
 - An existing branch (local or on origin, e.g. a PR head) is checked out; anything else is created from `<base>` (default: the repo's default branch). Safe to re-run.
-- Stay at the workspace root and reach into the worktree by the printed path. Never switch branches in an existing worktree or work in the clone `repos/<repo>` (it's for people working on one thing at a time).
-- After the branch merges: `git -C repos/<repo> worktree remove ../../worktrees/<repo>/<branch>`.
+- Stay at the workspace root and reach into the worktree by the printed path. Never switch branches in an existing worktree or work in its store, `worktrees/<repo>/.bare`.
+- Keep `worktrees/<repo>/<default-branch>/` (made by setup) a clean reference: fetch and fast-forward only.
+- After the branch merges: `git -C worktrees/<repo>/.bare worktree remove ../<branch>`.

From d23edb0194e43643ecf039a19cc07bff2ac8e189 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 01:16:11 +0000
Subject: [PATCH 16/19] delphi: sync inherited files from main

---
 .claude/skills/consolidate-spikes/SKILL.md |  6 +++---
 .claude/skills/create-ticket/SKILL.md      | 14 +++++++-------
 .claude/skills/report-spike/SKILL.md       |  2 +-
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/.claude/skills/consolidate-spikes/SKILL.md b/.claude/skills/consolidate-spikes/SKILL.md
index 057c827..4f85b66 100644
--- a/.claude/skills/consolidate-spikes/SKILL.md
+++ b/.claude/skills/consolidate-spikes/SKILL.md
@@ -6,8 +6,8 @@ description: Turn finished spikes into implementation tickets: an idea's spikes,
 Drafts and files by the `create-ticket` rules; load it and the project's `ticket-conventions` first. Takes an idea or a standalone spike.
 
 1. **Gather** each spike's findings comment, draft PR, and the PR's reviews; from an idea, its sub-issues too.
-2. **Check it's done.** Every spike is done by `create-ticket`'s Spikes rules (the lead's latest review on its draft PR, from repos/<owner>/<repo>/pulls/<pr>/reviews, is an approval). From an idea, that's every spike under it, and every approach is covered by a spike area. Otherwise list what's missing, offer spikes for uncovered approaches, and stop.
-3. **Choose:** per area (title prefix), propose the direction to build (one spike's, or a mix) with a one-line why, from the findings and the lead's review. The user confirms or changes each.
-4. **Plan** the dev work by `create-ticket`'s Dev work rules: one ticket unless the work is large enough to split into vertical slices, which may cross areas. Each ticket: What, the slice; Notes, links to the spikes and draft PRs it draws on, and the dropped directions with why; context transfer, the findings' facts.
+2. **Check it's done.** Every spike is done by `create-ticket`'s Spikes rules (the lead's latest review on its draft PR, from repos/<owner>/<repo>/pulls/<pr>/reviews, is an approval). From an idea, that's every spike under it, and every one of its areas to explore is covered by a spike area. Otherwise list what's missing, offer spikes for uncovered areas, and stop.
+3. **Choose:** per area (title prefix), propose the approach to build (one spike's, or a mix) with a one-line why, from the findings and the lead's review. The user confirms or changes each.
+4. **Plan** the dev work by `create-ticket`'s Dev work rules: one ticket unless the work is large enough to split into vertical slices, which may cross areas. Each ticket: What, the slice; Notes, links to the spikes and draft PRs it draws on, and the dropped approaches with why; context transfer, the findings' facts.
 5. **Draft** them, and, from an idea or when split, one epic (From: the idea or spike) with the dev work as its sub-issues. Show all, with which slices run in parallel if split; file what the user OKs.
 6. **Close**, each with a one-line comment: the spikes as completed ("Consolidated into #<epic or dev work>"), their draft PRs unless a dev work ticket builds on that branch, and the idea as completed ("Settled in #<epic or dev work>").
diff --git a/.claude/skills/create-ticket/SKILL.md b/.claude/skills/create-ticket/SKILL.md
index 47b8960..210a059 100644
--- a/.claude/skills/create-ticket/SKILL.md
+++ b/.claude/skills/create-ticket/SKILL.md
@@ -15,8 +15,8 @@ idea → spikes → epic → dev work, or a standalone spike → dev work
 
 | Ticket | What it is | Issue type | Parent |
 |---|---|---|---|
-| Idea | What could be built and why. Its approaches are areas (open questions), each with directions worth trying. | none | none |
-| Spike | One direction to try in one area of an idea, or a small standalone improvement: what is tried and the hypothesis. Findings go in a comment and a draft PR (`report-spike`), not the ticket. | none | its idea, if any |
+| Idea | What could be built and why. Its areas to explore are things to improve or problems to solve, each with approaches worth trying. | none | none |
+| Spike | One approach to try on one area of an idea (it needn't cover the whole area), or a small standalone improvement: what is tried and the hypothesis. Findings go in a comment and a draft PR (`report-spike`), not the ticket. | none | its idea, if any |
 | Epic | Work too large for one dev work ticket: the goal and whole-epic outcomes, not a walkthrough of each ticket. A new issue linking the idea or spike it came from in "From". | Feature | none |
 | Dev work | Any implementation work: testable requirements, Notes for gotchas and pointers to code. Large work is cut into vertical slices (see Dev work below). | Feature, Bug, or Task | its epic, if any |
 
@@ -43,12 +43,12 @@ How every ticket reads, on any project:
 
 ## Spikes
 
-- One direction, not a set to choose between. If a spike reads "X or Y", it is two spikes.
-- Prefer an idea with a few spikes (often 2-4) under it; a spike can also stand alone, or with siblings, to explore an area.
-- Title it `<area>: <direction>`, with the area a short kebab-case name its siblings share (`graph-saving: Save a graph to a file and re-upload it`). An area may cover more than one of an idea's bullets. A lone small improvement needs no prefix.
-- Sibling spikes share the context transfer's summary and common facts; each adds only the facts particular to its direction.
+- One approach, not a set to choose between. If a spike reads "X or Y", it is two spikes.
+- Prefer an idea with a few spikes (often 2-4) under it; a spike can also stand alone, or with siblings, to explore an area. Several spikes can take on the same area in different ways.
+- Title it `<area>: <approach>`, with the area a short kebab-case name its siblings share (`graph-saving: Save a graph to a file and re-upload it`). An area may cover more than one of an idea's bullets. A lone small improvement needs no prefix.
+- Sibling spikes share the context transfer's summary and common facts; each adds only the facts particular to its approach.
 - An idea needn't get all its spikes at once: file an area's spikes when someone is ready to try them.
-- Done: its findings are posted, review feedback is addressed, and the lead's latest review on its draft PR is an approval (GitHub's Approve), including when the recommendation is to drop the direction. A done spike stays open until `consolidate-spikes` closes it.
+- Done: its findings are posted, review feedback is addressed, and the lead's latest review on its draft PR is an approval (GitHub's Approve), including when the recommendation is to drop the approach. A done spike stays open until `consolidate-spikes` closes it.
 
 ## Draft
 
diff --git a/.claude/skills/report-spike/SKILL.md b/.claude/skills/report-spike/SKILL.md
index 946b0bb..e673871 100644
--- a/.claude/skills/report-spike/SKILL.md
+++ b/.claude/skills/report-spike/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: report-spike
-description: Post a spike's findings on its ticket, judged against its hypothesis, and ask the lead to review its draft PR. Use when a spike's direction has been tried on an application-software repo (Argos, Nero).
+description: Post a spike's findings on its ticket, judged against its hypothesis, and ask the lead to review its draft PR. Use when a spike's approach has been tried on an application-software repo (Argos, Nero).
 ---
 
 A spike runs like any ticket (branch, commits, a draft PR from `open-pr`); this reports it. Load the project's `pr-conventions` first.

From 86a44a1587a4ebea95cf7424cb45b57b67300d4c Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 16:13:50 +0000
Subject: [PATCH 17/19] delphi: sync inherited files from main

---
 .claude/skills/implement/SKILL.md    | 11 ++++++-----
 .claude/skills/new-worktree/SKILL.md |  1 +
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/.claude/skills/implement/SKILL.md b/.claude/skills/implement/SKILL.md
index 1b70ad1..f24d293 100644
--- a/.claude/skills/implement/SKILL.md
+++ b/.claude/skills/implement/SKILL.md
@@ -1,13 +1,14 @@
 ---
 name: implement
-description: Implement an Argos ticket or task in its own worktree, test-first, ending in a commit. Use when the user asks to build, fix, or implement something in Argos.
+description: Implement an Argos ticket or task in its own worktree, test-first, ending in a commit, here or in a subagent (one per ticket, in parallel, for several). Use when the user asks to build, fix, or implement something in Argos.
 ---
 
 1. **Worktree.** Get the ticket's branch (`{issue-number}-{kebab-case-title}`) with the `new-worktree` skill, based on `origin/develop`. Make every change in `worktrees/argos/<branch>/`, never in `worktrees/argos/develop/`, while staying at the workspace root: edit files by path, `git -C worktrees/argos/<branch> …` for git, and one-off subshells for the rest. Run `(cd worktrees/argos/<branch>/angular-client && npm ci)` before touching the client.
-2. **Understand.** Read the issue (`gh issue view <n> --comments`), the code involved, and `docs/CONTEXT.md` terms.
-3. **Build test-first**, one behavior at a time: a failing test, the least code to pass it, refactor while green. Test through public interfaces; mock only at system boundaries.
-4. **Check.**
+2. **Hand off?** Unless the user already chose, ask whether a subagent should do the rest, and recommend one: one per ticket, in parallel, when there are several (step 1 for each first), or one for work long enough to fill this conversation. Tell it the ticket, its worktree's absolute path, and to follow this skill from step 3, change files only under that path (`git -C` for git), name temp files after the branch, stop the clients it starts, and report its commits, checks, and the port and browser it used. Never turn on the harness's own worktree isolation (`new-worktree` says why). Then confirm its commits with `git -C <path> log origin/develop..` and pass its report on.
+3. **Understand.** Read the issue (`gh issue view <n> --comments`), the code involved, and `docs/CONTEXT.md` terms.
+4. **Build test-first**, one behavior at a time: a failing test, the least code to pass it, refactor while green. Test through public interfaces; mock only at system boundaries.
+5. **Check.**
    - Frontend, in `(cd worktrees/argos/<branch>/angular-client && …)`: `npx ng test --include='src/**/thing.spec.ts' --watch=false` while iterating; at the end `npx ng test --watch=false` (bare `ng test` blocks), then `npx prettier --check "src/**/*.{ts,html,scss}" && npx ng lint`.
    - Backend, in `(cd worktrees/argos/<branch>/scylla-server && …)`: `cargo build` and single tests while iterating; `cargo test` at the end.
    - UI changes: verify in the running app with `run-local <branch>`.
-5. **Commit** with `/commit`. Don't push or open a PR unless asked; that's `/open-pr`.
+6. **Commit** with `/commit`. Don't push or open a PR unless asked; that's `/open-pr`.
diff --git a/.claude/skills/new-worktree/SKILL.md b/.claude/skills/new-worktree/SKILL.md
index 0520aa7..0495fc9 100644
--- a/.claude/skills/new-worktree/SKILL.md
+++ b/.claude/skills/new-worktree/SKILL.md
@@ -11,5 +11,6 @@ bash .delphi/new-worktree.sh <repo> <branch> [<base>]
 
 - An existing branch (local or on origin, e.g. a PR head) is checked out; anything else is created from `<base>` (default: the repo's default branch). Safe to re-run.
 - Stay at the workspace root and reach into the worktree by the printed path. Never switch branches in an existing worktree or work in its store, `worktrees/<repo>/.bare`.
+- For a subagent, make its worktree here first and hand it the path. Never use the harness's own worktree isolation: it checks out this Delphi clone from main, not the code repo, and fences the subagent out of `worktrees/`.
 - Keep `worktrees/<repo>/<default-branch>/` (made by setup) a clean reference: fetch and fast-forward only.
 - After the branch merges: `git -C worktrees/<repo>/.bare worktree remove ../<branch>`.

From 6e6f25012a3511386c1778a283d575cad61e34b9 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 25 Oct 2026 02:42:36 +0000
Subject: [PATCH 18/19] delphi: sync .delphi/ from main

---
 .delphi/manifest.yml                          |  2 +-
 .../2.0.0-bare-repos-to-worktree-store.sh     | 27 +++++++++++++++++++
 .delphi/versions                              |  1 +
 3 files changed, 29 insertions(+), 1 deletion(-)
 create mode 100644 .delphi/migrations/2.0.0-bare-repos-to-worktree-store.sh

diff --git a/.delphi/manifest.yml b/.delphi/manifest.yml
index 8546a04..335e3b7 100644
--- a/.delphi/manifest.yml
+++ b/.delphi/manifest.yml
@@ -6,7 +6,7 @@
 #   MINOR  something new that existing clones need nothing for
 #   MAJOR  clones need cleanup (MINOR while 0.x): add .delphi/migrations/<version>-<slug>.sh, which
 #          setup.sh runs once per workspace in each clone (rules in Delphi's CLAUDE.md)
-version: 1.2.0
+version: 2.0.0
 files:                        # repo-relative paths; a trailing / means everything under it
   - .delphi/manifest.yml
   - .delphi/.gitattributes
diff --git a/.delphi/migrations/2.0.0-bare-repos-to-worktree-store.sh b/.delphi/migrations/2.0.0-bare-repos-to-worktree-store.sh
new file mode 100644
index 0000000..0b08f1c
--- /dev/null
+++ b/.delphi/migrations/2.0.0-bare-repos-to-worktree-store.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# 2.0.0: a bare repos/<name> (the store before 1.1.0) becomes the worktree store, worktrees/<name>/.bare,
+# and repos/<name> is vacated for setup.sh to clone normally. Moves it (git worktree repair, so its
+# worktrees follow) and sets origin/HEAD. Skips, reporting why, one with no origin, one whose branches or
+# worktree HEADs aren't on origin, or whose .bare exists, or that can't be fetched to check.
+set -euo pipefail
+for d in repos/*; do
+  [ -d "$d" ] || continue
+  [ "$(git -C "$d" rev-parse --is-bare-repository 2>/dev/null)" = true ] || continue
+  name=${d#repos/}
+  to=worktrees/$name/.bare
+  skip() { echo "migrate: $d $1; left it (move it to $to by hand)" >&2; }
+  git -C "$d" remote get-url origin >/dev/null 2>&1 || { skip "has no origin remote"; continue; }
+  [ ! -e "$to" ] || { skip "and $to both exist"; continue; }
+  git -C "$d" fetch -q origin '+refs/heads/*:refs/remotes/origin/*' </dev/null 2>/dev/null || { skip "could not be fetched from origin"; continue; }
+  heads=$({ git -C "$d" for-each-ref --format='%(objectname)' refs/heads
+    git -C "$d" worktree list --porcelain | awk '/^HEAD / { print $2 }'; } | grep -v '^0*$' | sort -u)
+  # shellcheck disable=SC2086 # object names
+  if [ -n "$heads" ] && [ -n "$(git -C "$d" rev-list $heads --not --remotes=origin | head -n 1)" ]; then
+    skip "has branches or worktree commits not on origin"; continue
+  fi
+  mkdir -p "worktrees/$name"
+  mv "$d" "$to"
+  git -C "$to" worktree repair "$PWD"/worktrees/"$name"/* 2>/dev/null || true
+  git -C "$to" remote set-head origin -a >/dev/null </dev/null || true
+  echo "migrate: moved $d to $to"
+done
diff --git a/.delphi/versions b/.delphi/versions
index 2fa678d..b5e272d 100644
--- a/.delphi/versions
+++ b/.delphi/versions
@@ -17,3 +17,4 @@
 1.0.0 44693a895995 1.0: workspaces: clones live at workspaces/<name> (was linked/<name>; DELPHI_WORKSPACES, was DELPHI_LINKED); setup.sh also runs each one's own setup.sh, and a workspace inside another's workspaces/ skips its own workspaces: (migration)
 1.1.0 a3446f7f763c setup.sh clones each repos: entry at repos/<name> (a normal clone on its default branch, was a bare store) and adds no worktree; new-worktree.sh makes worktrees from that clone; older bare stores are left as they are
 1.2.0 d139aaf9f4a5 worktrees come from their own bare store, worktrees/<name>/.bare, separate from the plain clone at repos/<name>; setup.sh makes the store and the default-branch worktree again; an older bare store at repos/<name> is left as it is
+2.0.0 750acf945979 a bare repos/<name> from before 1.1.0 becomes the worktree store, worktrees/<name>/.bare, with its worktrees, and repos/<name> is cloned normally (migration; skipped with a message if it has no origin or work not on origin)

From e34e77a44e94c23a1a060eeaa124356e24b729de Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 25 Oct 2026 02:42:51 +0000
Subject: [PATCH 19/19] delphi: sync inherited files from main

---
 .claude/skills/open-pr/SKILL.md        | 2 +-
 .claude/skills/pr-conventions/SKILL.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.claude/skills/open-pr/SKILL.md b/.claude/skills/open-pr/SKILL.md
index b1e7c71..368e6d9 100644
--- a/.claude/skills/open-pr/SKILL.md
+++ b/.claude/skills/open-pr/SKILL.md
@@ -7,7 +7,7 @@ First load the project's `pr-conventions` skill (inherited from the project's `w
 
 1. **Check:** `bash scripts/pr-checks.sh <repo> <branch> origin/<base> '<commit format>'` (clean tree, commit subjects match the project's format, merges cleanly into the base), then the project's own checks. Stop and fix on any FAIL.
 2. **Media:** if the diff touches the UI, ask the user whether to add screenshots to the PR, listing any already in the project's screenshot folder for this branch so they can pick those instead of new ones; on no, skip this step. For new ones, use the project's UI QA to take Playwright screenshots of the changed views into its screenshot folder, or, when the change adds or changes an animation, record a short video instead (a browser context with `recordVideo: { dir }` saves a `.webm` when it closes). Images must be under 10 MB; video under 10 MB on a Free plan, 100 MB on a paid one.
-3. **Open:** push (`git -C worktrees/<repo>/<branch> push -u origin <branch>`), then run `(cd worktrees/<repo>/<branch> && gh pr create --draft --base <base> --head <branch> --title "<title>" --body-file /tmp/<branch>-pr-body.md --assignee @me)` with the project's labels (`--label`) and one `--attach <file>` per screenshot or video, and report the URL.
+3. **Open:** push (`git -C worktrees/<repo>/<branch> push -u origin <branch>`), then run `(cd worktrees/<repo>/<branch> && gh pr create --draft --base <base> --head <branch> --title "<title>" --body-file /tmp/<branch>-pr-body.md --assignee @me)` with the project's labels plus the ticket's category label from `create-ticket`'s Labels (one `--label` each; only spikes and dev work get PRs, never ideas or epics) and one `--attach <file>` per screenshot or video, and report the URL.
 4. **Spike:** the PR stays a draft; getting it merged isn't the goal. Once it's checked and working, run `report-spike`.
 
 ## PR body
diff --git a/.claude/skills/pr-conventions/SKILL.md b/.claude/skills/pr-conventions/SKILL.md
index 90cc657..2265e4f 100644
--- a/.claude/skills/pr-conventions/SKILL.md
+++ b/.claude/skills/pr-conventions/SKILL.md
@@ -10,6 +10,6 @@ The shared rules are in the `open-pr` skill; this adds only what is Argos's.
 
 - Base branch: `develop`. Commit format: `^#[0-9]+ - ` (the format in CLAUDE.md).
 - Checks: `bash scripts/lint.sh <branch>` (frontend prettier and ng lint, only if angular-client/ changed).
-- Labels: one written-by (`by: human` if the user wrote it, `by: ai-assisted` if they gave the substance, `by: ai` if you wrote it) and at least one area label (`frontend`, `backend`, `devops`); no category label.
+- Labels: one written-by (`by: human` if the user wrote it, `by: ai-assisted` if they gave the substance, `by: ai` if you wrote it) and at least one area label (`frontend`, `backend`, `devops`), besides `open-pr`'s category label.
 - Screenshots: `pictures/<branch>/` at the worktree root (git-ignored).
 - UI QA: get the branch running with `run-local <branch>`, then drive it with Playwright, using the `playwright-cdp` server if `curl -s localhost:9222/json/version` responds, otherwise `playwright`.