@litfamily/litmuse 0.1.8 → 0.1.9

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.9 — 2026-11-06
+
+- lit-schematic QA catches three more drawing faults: a symbol that touches no line (a vent floating above a tank roof), a label pressed against a line or a circle with no air around it, and a line drawn straight through an open symbol. Tank tags can sit to the right of the tank. The legend rows have more room, and the dosing-skid example was relaid so the relief line no longer crosses pump A.
+- lit-schematic arrows can point any way, tags of vertical inline parts sit beside the pipe instead of on it, and the PSV symbol is redrawn.
+
 ## 0.1.8 — 2026-11-04
 
 - `install --approve` no longer prints a stale waiting list computed before approving. It now says it is approving the capabilities, then reports what was approved and lists only what is really still waiting (or says none are). Without `--approve` the waiting list stays as it was.

package/README.md

@@ -11,11 +11,11 @@
 <a href="https://github.com/wjgoarxiv/litmuse/stargazers"><img src="https://img.shields.io/github/stars/wjgoarxiv/litmuse?style=flat" alt="GitHub stars" /></a>
 </p>
 
-<p align="center"><a href="#install">Install</a> &nbsp; <a href="#quick-start">Quick start</a> &nbsp; <a href="#the-status-card">Status card</a> &nbsp; <a href="#automatic-handoff">Handoff</a> &nbsp; <a href="#safety-and-uninstall">Safety</a> &nbsp; <a href="./README_ko-KR.md">한국어</a></p>
+<p align="center"><a href="#in-the-muse-app-too">Muse app</a> &nbsp; <a href="#install">Install</a> &nbsp; <a href="#quick-start">Quick start</a> &nbsp; <a href="#the-status-card">Status card</a> &nbsp; <a href="#automatic-handoff">Handoff</a> &nbsp; <a href="#safety-and-uninstall">Safety</a> &nbsp; <a href="./README_ko-KR.md">한국어</a></p>
 
 ## What a session looks like
 
-<p align="center"><img src="./docs/assets/readme/demo.webp" width="960" alt="Terminal capture of three real commands on this Mac. muse --version prints Muse Code 1.4.11. litmuse status --card shows the lit-plan route active with plan 0 of 2 and the next open row. litmuse models lists the muse-spark models from the host catalog." /></p>
+<p align="center"><img src="./docs/assets/readme/demo.webp" width="960" alt="Terminal card of three real commands in a test project. muse --version prints Muse Code 1.4.14. litmuse status --card shows the lit-plan route active for 30s with plan 0/2 in plans/todo-app.md and next row 1, Add the shout flag. litmuse models lists muse-spark-1.3 (default) and muse-spark-1.2 with their effort levels." /></p>
 
 Stripped to three lines, a planning session goes like this:
 
@@ -44,6 +44,14 @@ LitMuse gives each session a routine. Start a prompt with `lit` and the plugin's
 
 Muse still runs the session and picks the model. LitMuse adds the way of working, and it lives in plain files you can read.
 
+## In the Muse app too
+
+Meta ships two Muse products. Muse Code is the terminal agent this README is about. The Muse app is the desktop agent with a chat window, side chats, notes and tasks. LitFamily also works inside the Muse app: its lit skills load there the same way, and a reply opens with the same ignition mark you see in the terminal.
+
+The capture below is one new side chat in the Muse app. The prompt asks `/lit-brainstorm` for names for a small open-source note tool you use from the terminal. The answer opens with `🔥 LIT IGNITED · lit-brainstorm 🔥`, sets weighted criteria before scoring, first drops the names that are already taken (`jot`, `memo`, `mnemo`, `scratch`, `margin`), and then shows a scored table of the top ten.
+
+<p align="center"><img src="./docs/assets/muse-app/lit-brainstorm.webp" width="420" alt="One side chat in the Muse desktop app titled 터미널 메모 도구 이름 추천. The user prompt reads /lit-brainstorm followed by a Korean request for name ideas and scores for a small open-source terminal note tool. The reply starts with 🔥 LIT IGNITED · lit-brainstorm 🔥, says 32 candidates were drawn and taken names were removed first, lists weighted criteria on a 100-point scale, names jot, memo, mnemo, scratch and margin as dropped, and shows a top-10 score table led by termemo 87%, jotlet 80% and memlet 80%." /></p>
+
 ## Install
 
 You need Node.js 20 or newer and Muse Code, signed in once. In a terminal, run:
@@ -109,15 +117,15 @@ Read the card from top to bottom. The first line names the workflow and how long
 
 At rest the card reports no active route:
 
-<p align="center"><img src="./docs/assets/card/idle.webp" width="960" alt="The status card with no active route in this workspace." /></p>
+<p align="center"><img src="./docs/assets/card/idle.webp" width="960" alt="Terminal card of litmuse status --card with no route running: LIT, no active route in this workspace, plan 0/2 in plans/todo-app.md, next row 1, Add the shout flag." /></p>
 
 While a plan runs, the card names the route, the plan file, and the next open row:
 
-<p align="center"><img src="./docs/assets/card/working.webp" width="960" alt="The status card while the lit-plan route is active, naming the plan file with 0 of 2 rows ticked and the next open row." /></p>
+<p align="center"><img src="./docs/assets/card/working.webp" width="960" alt="Terminal card of litmuse status --card while lit-plan runs: LIT, lit-plan, active 30s, one lit-plan thread running, plan 0/2 in plans/todo-app.md, next row 1, Add the shout flag." /></p>
 
 Ticking a row moves the count and the next-row pointer:
 
-<p align="center"><img src="./docs/assets/card/after.webp" width="960" alt="The same card after the first row is ticked: 1 of 2 with the second row named next." /></p>
+<p align="center"><img src="./docs/assets/card/after.webp" width="960" alt="The same card after row 1 is ticked: plan 1/2 in plans/todo-app.md, next row 2, Write the tests." /></p>
 
 The card reads the hook-kept state under `~/.local/state/litmuse/`, outside the project.
 
@@ -127,17 +135,17 @@ A long session fills the model's context, and when Muse compacts it, detail drop
 
 The hook answers with one recorded line:
 
-<p align="center"><img src="./docs/assets/handoff/saved.webp" width="960" alt="The PreCompact hook output line recording that it saved .litmuse/handoff/latest.md." /></p>
+<p align="center"><img src="./docs/assets/handoff/saved.webp" width="960" alt="Terminal card of muse plugins hook test running the PreCompact hook: status completed, exit code 0, system message LitMuse saved .litmuse/handoff/latest.md." /></p>
 
 The snapshot names the trigger, the session, the route, the plan with its open rows, and recent ledger lines:
 
-<p align="center"><img src="./docs/assets/handoff/latest.webp" width="960" alt="The handoff snapshot: trigger, session, the lit-plan route, the plan with 0 ticked and 2 open rows, and recent ledger lines." /></p>
+<p align="center"><img src="./docs/assets/handoff/latest.webp" width="960" alt="Terminal card of cat .litmuse/handoff/latest.md: the LitMuse compaction snapshot with trigger manual, session readme-demo-01, route lit-plan, plan plans/todo-app.md with 0 ticked and 2 open, the next open row, and two recent ledger lines for read_file and write_file." /></p>
 
 ## What you can make
 
 Four real outputs rendered on a Mac during the quality parity round, each opened, read, and fixed until it looked right:
 
-<p align="center"><img src="./docs/assets/parity/lit-adhd-brief.png" width="960" alt="The lit-adhd brief in a real terminal: rainbow headline, one active session card with goal and work time, tools, the finished commit, and a boxed recommended next step." /></p>
+<p align="center"><img src="./docs/assets/parity/lit-adhd-brief.png" width="960" alt="Terminal card of litmuse rewind, the lit-adhd brief: a rainbow headline with 2 sessions and 0 waiting on you, a table of the two ended sessions in todo-app, the roadmap gauge for plans/todo-app.md at 1/2, and a boxed recommended next step to start the plan." /></p>
 
 `lit-adhd` briefs your live sessions: session cards with status badges, an ended table, and a boxed recommended step — colour on TTY, no internal field names leaking.
 
@@ -145,7 +153,7 @@ Four real outputs rendered on a Mac during the quality parity round, each opened
 
 `lit-pptx` compiles real decks from data: this one charts the port's own test-suite growth, wave by wave.
 
-<p align="center"><img src="./docs/assets/parity/lit-schematic-pid.png" width="960" alt="A lit-schematic P&ID: a sodium hypochlorite dosing skid with tank TK-101, duty and standby dosing pumps, a relief-valve spillback, instrument bubbles, line numbers, a drawn-symbol legend, and title block EX-PID-001." /></p>
+<p align="center"><img src="./docs/assets/parity/lit-schematic-pid.png" width="960" alt="A lit-schematic P&ID of a hypochlorite dosing skid, marked as a worked example with invented values: tank TK-101 with LT-101 and LIA-101, isolation valve HV-101 and strainer STR-101, duty and standby pumps P-101A and P-101B with check valves, PSV-101 set at 8 barg relieving back to the tank, PI-101 and FIT-101 on the discharge, line numbers, a legend, and title block EX-PID-001 rev B." /></p>
 
 `lit-schematic` draws QA-checked P&IDs: a dosing skid with real symbols, a drawn legend, line numbers, and a title block — seven look rounds until every label read cleanly.
 

package/README_ko-KR.md

@@ -11,11 +11,11 @@
 <a href="https://github.com/wjgoarxiv/litmuse/stargazers"><img src="https://img.shields.io/github/stars/wjgoarxiv/litmuse?style=flat" alt="GitHub stars" /></a>
 </p>
 
-<p align="center"><a href="#설치">설치</a> &nbsp; <a href="#빠른-시작">빠른 시작</a> &nbsp; <a href="#상태-카드">상태 카드</a> &nbsp; <a href="#자동-핸드오프">핸드오프</a> &nbsp; <a href="#안전과-제거">안전</a> &nbsp; <a href="./README.md">English</a></p>
+<p align="center"><a href="#muse-앱에서도">Muse 앱</a> &nbsp; <a href="#설치">설치</a> &nbsp; <a href="#빠른-시작">빠른 시작</a> &nbsp; <a href="#상태-카드">상태 카드</a> &nbsp; <a href="#자동-핸드오프">핸드오프</a> &nbsp; <a href="#안전과-제거">안전</a> &nbsp; <a href="./README.md">English</a></p>
 
 ## 세션은 이렇게 돌아갑니다
 
-<p align="center"><img src="./docs/assets/readme/demo.webp" width="960" alt="이 Mac에서 실행한 실제 명령 세 개의 터미널 캡처. muse --version은 Muse Code 1.4.11을 출력합니다. litmuse status --card는 lit-plan 경로가 활성 상태이며 계획이 0/2이고 다음 행을 가리킵니다. litmuse models는 호스트 카탈로그의 muse-spark 모델을 보여 줍니다." /></p>
+<p align="center"><img src="./docs/assets/readme/demo.webp" width="960" alt="테스트 프로젝트에서 실행한 실제 명령 세 개의 터미널 카드. muse --version은 Muse Code 1.4.14를 출력합니다. litmuse status --card는 lit-plan 경로가 30초째 활성이고 plans/todo-app.md 계획이 0/2이며 다음 행이 1. Add the shout flag임을 보여 줍니다. litmuse models는 muse-spark-1.3(기본)과 muse-spark-1.2, 각 모델의 effort 단계를 보여 줍니다." /></p>
 
 세 줄로 줄이면 계획 세션은 이렇게 흘러갑니다.
 
@@ -44,6 +44,14 @@ LitMuse는 세션마다 따라갈 순서를 줍니다. 프롬프트를 `lit`으
 
 세션을 돌리고 모델을 고르는 것은 여전히 Muse입니다. LitMuse는 일하는 방식을 더하고, 그 방식은 직접 읽을 수 있는 평범한 파일로 남습니다.
 
+## Muse 앱에서도
+
+Meta의 Muse 제품은 두 가지입니다. 이 README가 다루는 Muse Code는 터미널에서 쓰는 에이전트이고, Muse 앱은 채팅 창과 사이드챗, 노트, 할 일을 갖춘 데스크톱 에이전트입니다. LitFamily는 Muse 앱 안에서도 돌아갑니다. lit 스킬이 똑같이 불려 오고, 답은 터미널에서 보던 점화 표시로 시작합니다.
+
+아래 화면은 Muse 앱에서 새로 연 사이드챗 하나입니다. 터미널에서 쓰는 작은 오픈소스 메모 도구의 이름 후보를 `/lit-brainstorm`에 물었습니다. 답은 `🔥 LIT IGNITED · lit-brainstorm 🔥`로 시작하고, 점수를 매기기 전에 가중치 기준부터 정합니다. 이미 쓰이는 이름(`jot`, `memo`, `mnemo`, `scratch`, `margin`)을 먼저 걸러 낸 뒤 상위 10개 점수표를 보여 줍니다.
+
+<p align="center"><img src="./docs/assets/muse-app/lit-brainstorm.webp" width="420" alt="Muse 데스크톱 앱의 사이드챗 하나. 제목은 터미널 메모 도구 이름 추천. 사용자 프롬프트는 /lit-brainstorm 뒤에 작은 오픈소스 터미널 메모 도구의 이름 후보와 점수를 묻는 한국어 요청. 답은 🔥 LIT IGNITED · lit-brainstorm 🔥로 시작해, 후보 32개를 뽑고 이미 쓰이는 이름을 먼저 걸렀다고 말하고, 100점 환산 가중치 기준과 탈락한 jot, memo, mnemo, scratch, margin을 적은 뒤, termemo 87%, jotlet 80%, memlet 80%가 앞선 상위 10개 점수표를 보여 준다." /></p>
+
 ## 설치
 
 Node.js 20 이상과, 한 번 로그인해 둔 Muse Code가 필요합니다. 터미널에서 실행하세요.
@@ -109,15 +117,15 @@ Muse의 `/hud`는 켜고 끄는 고정 항목 목록이라서 플러그인 글
 
 쉴 때 카드는 활성 경로가 없다고 알립니다.
 
-<p align="center"><img src="./docs/assets/card/idle.webp" width="960" alt="활성 경로가 없는 상태의 상태 카드." /></p>
+<p align="center"><img src="./docs/assets/card/idle.webp" width="960" alt="실행 중인 경로가 없을 때의 litmuse status --card 터미널 카드. 이 워크스페이스에 활성 경로가 없고, plans/todo-app.md 계획은 0/2, 다음 행은 1. Add the shout flag입니다." /></p>
 
 계획이 돌 때 카드는 경로와 계획 파일, 다음 행을 보여 줍니다.
 
-<p align="center"><img src="./docs/assets/card/working.webp" width="960" alt="lit-plan 경로가 활성 상태인 카드. 계획 파일의 0/2행과 다음으로 풀 행을 가리킵니다." /></p>
+<p align="center"><img src="./docs/assets/card/working.webp" width="960" alt="lit-plan이 실행 중일 때의 litmuse status --card 터미널 카드. lit-plan이 30초째 활성이고 lit-plan 스레드 하나가 실행 중이며, plans/todo-app.md 계획은 0/2, 다음 행은 1. Add the shout flag입니다." /></p>
 
 행에 체크하면 개수와 다음 행 표시가 바뀝니다.
 
-<p align="center"><img src="./docs/assets/card/after.webp" width="960" alt="첫 행을 체크한 뒤의 같은 카드. 1/2이며 두 번째 행을 다음으로 가리킵니다." /></p>
+<p align="center"><img src="./docs/assets/card/after.webp" width="960" alt="1번 행을 체크한 뒤의 같은 카드. plans/todo-app.md 계획이 1/2가 되고 다음 행은 2. Write the tests입니다." /></p>
 
 카드는 프로젝트 밖에 있는 `~/.local/state/litmuse/` 아래 훅 기록을 읽습니다.
 
@@ -127,17 +135,17 @@ Muse의 `/hud`는 켜고 끄는 고정 항목 목록이라서 플러그인 글
 
 훅은 기록 한 줄로 답합니다.
 
-<p align="center"><img src="./docs/assets/handoff/saved.webp" width="960" alt="PreCompact 훅의 출력 한 줄. .litmuse/handoff/latest.md를 저장했다고 기록합니다." /></p>
+<p align="center"><img src="./docs/assets/handoff/saved.webp" width="960" alt="muse plugins hook test로 PreCompact 훅을 실행한 터미널 카드. 상태 completed, 종료 코드 0, 시스템 메시지 LitMuse saved .litmuse/handoff/latest.md." /></p>
 
 스냅샷에는 실행 계기, 세션, 경로, 열린 행이 있는 계획, 최근 기록 줄이 들어갑니다.
 
-<p align="center"><img src="./docs/assets/handoff/latest.webp" width="960" alt="인계 스냅샷. 실행 계기와 세션, lit-plan 경로, 0개 체크와 2개 열린 행의 계획, 최근 기록 줄을 보여 줍니다." /></p>
+<p align="center"><img src="./docs/assets/handoff/latest.webp" width="960" alt="cat .litmuse/handoff/latest.md 터미널 카드. LitMuse 압축 스냅샷으로 trigger manual, 세션 readme-demo-01, lit-plan 경로, 0개 체크와 2개 열린 행의 plans/todo-app.md 계획, 다음 열린 행, read_file과 write_file의 최근 기록 두 줄을 보여 줍니다." /></p>
 
 ## 만들 수 있는 것
 
 품질 패리티 라운드에서 Mac에서 직접 렌더한 결과물 4종입니다. 파일을 열어 눈으로 읽고, 어색한 곳은 고쳐 다시 렌더했습니다.
 
-<p align="center"><img src="./docs/assets/parity/lit-adhd-brief.png" width="960" alt="실제 터미널의 lit-adhd 브리프. 무지개 헤드라인, 목표와 작업 시간이 적힌 활성 세션 카드 하나, 도구, 완료된 커밋, 박스형 권장 다음 단계." /></p>
+<p align="center"><img src="./docs/assets/parity/lit-adhd-brief.png" width="960" alt="litmuse rewind로 출력한 lit-adhd 브리프의 터미널 카드. 세션 2개와 대기 0개를 알리는 무지개 헤드라인, todo-app에서 끝난 두 세션의 표, plans/todo-app.md의 1/2 로드맵 게이지, 계획 시작을 권하는 박스형 다음 단계." /></p>
 
 `lit-adhd`는 실행 중 세션을 브리핑합니다. 상태 뱃지가 달린 세션 카드와 종료 표, 박스형 권장 다음 단계 — 터미널 색상 그대로, 내부 필드 이름은 새지 않습니다.
 
@@ -145,7 +153,7 @@ Muse의 `/hud`는 켜고 끄는 고정 항목 목록이라서 플러그인 글
 
 `lit-pptx`는 자료로 실제 덱을 엮습니다. 이 덱은 포팅 웨이브별 테스트 스위트 증가를 그립니다.
 
-<p align="center"><img src="./docs/assets/parity/lit-schematic-pid.png" width="960" alt="lit-schematic P&ID. 탱크 TK-101, 상용·예비 도징 펌프, 릴리프 밸브 스필백, 계장 버블, 라인 번호, 심벌 범례, EX-PID-001 타이틀 블록을 갖춘 차아염소산나트륨 도징 스키드." /></p>
+<p align="center"><img src="./docs/assets/parity/lit-schematic-pid.png" width="960" alt="예시 값으로 그린 작업 예제임을 밝힌 lit-schematic 차아염소산나트륨 도징 스키드 P&ID. LT-101·LIA-101이 달린 탱크 TK-101, 차단 밸브 HV-101과 스트레이너 STR-101, 체크 밸브가 달린 상용·예비 펌프 P-101A·P-101B, 8 barg에서 탱크로 되돌리는 PSV-101, 토출 측 PI-101과 FIT-101, 라인 번호, 범례, EX-PID-001 rev B 타이틀 블록." /></p>
 
 `lit-schematic`은 QA를 통과한 P&ID를 그립니다. 실제 심벌과 범례, 라인 번호, 타이틀 블록을 갖춘 도징 스키드이며, 모든 라벨이 읽힐 때까지 일곱 번 고쳐 그렸습니다.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litfamily/litmuse",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Installer for LitMuse: skills, hooks and agents that help Meta's Muse Code plan, build, check and hand off work.",
   "keywords": [
     "muse",

package/plugin/.muse-plugin/plugin.json

@@ -2,7 +2,7 @@
   "schemaVersion": 1,
   "name": "litmuse",
   "displayName": "LitMuse",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "LitFamily workflows for Muse Code: bare lit activation, planning, evidence-bound execution, review, research, handoff and Korean prose care.",
   "compat": {
     "source": "native",

package/plugin/skills/lit-schematic/examples/pid-dosing-skid/build.mjs

@@ -16,57 +16,65 @@ sheet.equipmentInfo('P-101B', 'Dosing pump, 0-40 L/h at 6 barg, standby');
 sheet.notes([
   'Line numbers read size-fluid-sequence.',
   'Pumps P-101A/B: duty and standby; one runs.',
-  'PSV-101 spills pump discharge back to suction.',
+  'PSV-101, set 8 barg, spills back to suction.',
 ]);
 
 // Feed from unloading into the tank. The off-page box sits clear of the
-// level instruments, and the loop tag goes left so it never meets the tank.
-sheet.offpage('FROM UNLOADING', 12, 106, 'out', 64);
-sheet.pipe([[76, 106], [118, 106]], { cls: 'process', number: '2-NAOCL-100', at: 0.548 });
-sheet.tank('TK-101', 140, 130);
-sheet.vent(140, 76);
-sheet.instrument('LT-101', 78, 140, { tag: 'below' });
-sheet.signal([[91, 140], [118, 140]], 'electric');
-sheet.instrument('LIA-101', 78, 80, { dcs: true, tag: 'left' });
+// level instruments; each bubble carries its own tag, so none is printed beside it.
+sheet.offpage('FROM UNLOADING', 12, 110, 'out', 64);
+sheet.pipe([[76, 110], [121, 110]], { cls: 'process', number: '2-NAOCL-100', at: 0.52 });
+sheet.tank('TK-101', 143, 126, 'right'); // tag beside the shell, clear of the outlet and the PSV
+sheet.vent(143, 80); // leg starts on the roof nozzle
+sheet.instrument('LT-101', 78, 140);
+sheet.signal([[91, 140], [121, 140]], 'electric');
+sheet.instrument('LIA-101', 78, 80, { dcs: true });
 sheet.signal([[78, 93], [78, 127]], 'electric');
 
-sheet.pipe([[140, 156], [140, 182]], { cls: 'process' });
+sheet.pipe([[143, 152], [143, 182]], { cls: 'process' });
 sheet.pipe([[40, 182], [250, 182]], { cls: 'process', number: '2-NAOCL-101', at: 0.24 });
 sheet.drain(60, 182);
 sheet.valve('gate', 'hand', 'FV-101', 120, 182, 'FC');
-sheet.strainer('STR-101', 150, 182);
-sheet.arrow(134, 182, true);
+sheet.strainer('STR-101', 157, 182);
+sheet.arrow(96, 182, true);
 
-// Duty and standby pump branches. Tags sit beside the circles: a vertical drop
-// through a centered tag would strike it, and the checks below need the room.
+// Duty and standby pump branches, far enough apart that the standby tag clears
+// the duty pump's circle. Pump tags sit beside the circles: a vertical
+// drop through a centered tag would strike it. The check valves on the vertical
+// discharge drops take their tags beside the pipe, to the right, clear of the drop.
 sheet.pipe([[188, 182], [188, 190]], { cls: 'process' });
 sheet.pump('P-101A', 188, 200, 'left');
 sheet.pipe([[188, 210], [188, 232]], { cls: 'process' });
-sheet.valve('check', 'auto', 'XV-101A', 188, 224, 'FC', 'v');
-sheet.pipe([[234, 182], [234, 190]], { cls: 'process' });
-sheet.pump('P-101B', 234, 200, 'left');
-sheet.pipe([[234, 210], [234, 232]], { cls: 'process' });
-sheet.valve('check', 'auto', 'XV-101B', 234, 224, 'FC', 'v');
+sheet.valve('check', 'auto', 'XV-101A', 188, 219, 'FC', 'v', 'right');
+sheet.pipe([[240, 182], [240, 190]], { cls: 'process' });
+sheet.pump('P-101B', 240, 200, 'left');
+sheet.pipe([[240, 210], [240, 232]], { cls: 'process' });
+sheet.valve('check', 'auto', 'XV-101B', 240, 219, 'FC', 'v', 'right');
 
 // Discharge header to the injection riser. The globe sits west of the duty
-// branch with its fail tag clear of the drop; the line number rides east of it.
-sheet.pipe([[120, 232], [246, 232]], { cls: 'process', number: '2-NAOCL-102', at: 0.72 });
+// branch with its fail tag clear of the drop; the line number rides between the
+// two pump drops, under the duty check valve's tag. The riser runs east of the
+// standby tag, and its flow arrow points up.
+sheet.pipe([[128, 232], [284, 232]], { cls: 'process', number: '2-NAOCL-102', at: 0.532 });
 sheet.valve('globe', 'pneumatic', 'FV-102', 140, 232, 'FO');
-sheet.pipe([[246, 232], [246, 100]], { cls: 'process' });
-sheet.orifice('FE-101', 246, 140);
-sheet.instrument('FT-101', 266, 160);
-sheet.signal([[253, 160], [250, 160], [250, 150]], 'electric');
-sheet.instrument('PI-101', 270, 214);
-sheet.pipe([[257, 214], [246, 214]], { cls: 'utility' });
+sheet.pipe([[284, 232], [284, 100]], { cls: 'process' });
+sheet.arrow(284, 186, true, 'up');
+sheet.orifice('FE-101', 284, 140);
+sheet.instrument('FT-101', 266, 165);
+sheet.signal([[266, 151.8], [266, 140], [281, 140]], 'electric');
+sheet.instrument('PI-101', 268, 200);
+sheet.pipe([[281.2, 200], [284, 200]], { cls: 'utility' });
 sheet.instrument('FIC-101', 198, 96, { dcs: true });
-sheet.signal([[198, 109], [198, 144]], 'electric');
-sheet.offpage('TO INJECTION POINT', 246, 100, 'out', 60);
+sheet.signal([[198, 109], [198, 165], [252.8, 165]], 'electric'); // FIC reads FT-101
+sheet.offpage('TO INJECTOR', 284, 100, 'out');
 
-// PSV spillback to the suction header, west of the duty branch so the tags,
-// the tank outlet, and the line number each keep their own lane.
-sheet.pipe([[180, 232], [180, 170]], { cls: 'process' });
-sheet.psv('PSV-101', 180, 160, 'SET 8 barg');
-sheet.pipe([[186, 156], [186, 150], [206, 150], [226, 150], [226, 184]], { cls: 'process', number: '1-NAOCL-103', at: 0.5 });
+// PSV spillback, between the two headers west of the globe valve: the angle body
+// takes its inlet from the discharge header below and spills right, then up into
+// the suction header, so no line crosses a pump. The tag sits opposite the outlet;
+// the set pressure rides in note 3.
+sheet.pipe([[128, 232], [128, 224]], { cls: 'process' });
+sheet.psv('PSV-101', 128, 214, null, { outlet: 'right' });
+sheet.pipe([[138, 214], [138, 182]], { cls: 'process' });
+sheet.arrow(138, 196, true, 'up');
 
 sheet.legend();
 writeFileSync(join(out, 'drawing.svg'), sheet.toSVG());

package/plugin/skills/lit-schematic/references/kit-api.md

@@ -8,6 +8,21 @@ Import the kit root and construct sheets, figures, and views from it.
 `pipe(from, to, opts)`, `signal(from, to, kind)`, `inline(line, item)`, `equipmentInfo(tag,
 info)`.
 
+P&ID sheet methods that place parts (coordinates in sheet mm):
+- `pipe(points, { cls, number, at })` routes orthogonally; `number` rides above a horizontal run
+  or, rotated, 8 mm right of a vertical one, `at` along the longest segment.
+- `arrow(x, y, clear = true, dir = 'right')` draws an open flow chevron with its tip at
+  (x, y); `dir` is `right`, `left`, `up` or `down` and must match the flow on that run.
+- `valve(body, actuator, id, x, y, fail = 'FC', orient = 'h', tagSide = 'left')`: with
+  `orient: 'v'` the actuator points right and the tag goes beside the pipe, left by default or
+  right of the actuator with `tagSide: 'right'`.
+- `strainer(id, x, y, orient = 'h', tagSide = 'left')`: same rule on a vertical pipe.
+- `psv(tag, x, y, set, { outlet = 'right', inlet })`: angle body, spring opposite the inlet,
+  tag opposite the outlet; inlet and outlet pipes connect 10 from the center.
+- `instrument(tag, x, y, { dcs })`: the bubble holds the tag (letters over number); no side tag.
+- `pump(tag, x, y, side)`, `tank(tag, x, y, side)` (side `below` or `right`; its roof nozzle top is `y - 46`), `orifice`, `offpage(label, x, y, dir, w)`, `drain`, `vent`,
+  `signal(points, kind)`, `hop`, `callout`, `notes`, `legend()`, `toSVG()`.
+
 `createFigure(opts)` returns a journal figure with column width (`85`, `120`, `178`).
 `panel.canvas()` opens a 2D panel; `panel.iso(view)` opens a 3D panel with the isometric
 camera. `fig.key(roles, at)` draws the stream key. `stream({ role })` colours a stream from

package/plugin/skills/lit-schematic/references/pid-drafting.md

@@ -10,8 +10,12 @@ process piping. A line that cannot route throws with the reason; move a symbol o
 waypoints, and route around symbols.
 
 Inline items (valves, filters, flow elements, reducers) sit on the line through `sheet.inline`.
-Branches leave through `line.tap` at straight runs. Asked-for flow arrows slide along open
-pipe to clear spans; a span shorter than 30 mm takes a warn flag.
+On a vertical pipe, draw valves with `orient: 'v'` and strainers with `'v'`: their tag moves
+beside the pipe (left by default, `'right'` to pass the actuator side) instead of sitting on it.
+A vertical line number reads bottom-to-top, 8 mm right of its line, with the same air as a
+horizontal number. Branches leave through `line.tap` at straight runs. Asked-for flow arrows
+slide along open pipe to clear spans and point the way the flow runs (`right`, `left`, `up`,
+`down`); a span shorter than 30 mm takes a warn flag.
 
 Line hops: arcs of radius 2 mm or less mark crossings; larger arcs read as bends and fail the
 bend check. Leaders keep 1.2 mm at print size between leaders and between leaders and dots,

package/plugin/skills/lit-schematic/references/pid-symbols.md

@@ -5,8 +5,9 @@ P pressure, T temperature), succeeding letters the function (I indicate, C contr
 V valve). Tag order follows the letter table; the QA gate flags letter-order breaks.
 
 Bubbles carry function plus location: a plain circle for field instruments, a horizontal bar
-for panel-board mounting, a dashed outline for computer-resident functions. Every bubble shows
-its loop tag beside it.
+for panel-board mounting, a dashed outline for computer-resident functions. The bubble itself
+is the tag: letters on the upper line, loop number on the lower. `sheet.instrument` prints no
+second copy beside it; its old `tag` placement option is accepted and ignored.
 
 Line types: process lines heavy (0.7), utility lines medium (0.5), instrument connections and
 signal lines light (0.35), with leader dots at 0.18. Process, utility, and signal lines stay
@@ -22,6 +23,13 @@ form, eccentric reducer, flange pair, venturi and magnetic/Coriolis/vortex flow
 figure-8 spectacle blind, line-size breaks, strainers, traps, rupture disks, PSVs with
 discharge destinations.
 
+The PSV is an angle body: an inlet triangle and an outlet triangle meet at the body center, the
+spring rises from the center on the side opposite the inlet (never over the inlet stem), and the
+tag plus set pressure sit on the side opposite the outlet. `sheet.psv(tag, x, y, set, { outlet,
+inlet })` takes `outlet` right (default), left, up or down; `inlet` defaults to down for a
+sideways outlet and left for a vertical one, and must sit at a right angle to the outlet. Pipes
+connect 10 mm from the center along each direction.
+
 Line numbers parse through a small grammar (size, fluid code, class, sequence) with a dedicated
 QA check. Signal marks follow ISA-5.1 Table 5.3.2 for pneumatic, electric, capillary, and
 software links.

package/plugin/skills/lit-schematic/references/verification.md

@@ -2,13 +2,20 @@
 
 QA codes (`qa.mjs --codes` lists all): TITLEBLOCK.FIELDS, LEGEND.COVERAGE, TAG.ORDER,
 LINE.NUMBER, LINE.WEIGHT, LINE.ARROW_IN_SYMBOL, LINE.BEND_ON_LINE, LEADER.SPACING,
-LABEL.CLEARANCE, EXPORT.DPI, EXPORT.PDF_SIZE.
+LABEL.CLEARANCE, SYMBOL.CONNECTED, LINE.THROUGH_SYMBOL, EXPORT.DPI, EXPORT.PDF_SIZE.
 
 Fixes: TITLEBLOCK gains the missing fields in the build. LEGEND rebuilds from the drawn set
 through `createLegendSheet`. TAG reorders letters per `references/pid-symbols.md`.
 LINE.NUMBER parses through the line grammar. LINE.WEIGHT remaps roles to 0.7/0.5/0.35/0.18.
 Arrows slide to open pipe. Hop arcs shrink to 2 mm or less. Leaders respread per
-`references/pid-drafting.md`. Labels move clear of lines and art.
+`references/pid-drafting.md`. Labels move clear of lines and art. LABEL.CLEARANCE also
+flattens arcs and curves (vent hoods, actuator domes, hop arcs) and checks every circle: a label
+across a bubble or pump outline fails (`sits on a circle`), while a bubble's own letters, wholly
+inside it, pass. Against lines and outlines a label needs 0.3 mm of air: a line number touching a
+vessel wall or a signal line fails. SYMBOL.CONNECTED fails a vent whose leg meets no nozzle, vessel or
+pipe; start the vent on the nozzle's top edge (for `tank(tag, x, y)` that is `vent(x, y - 46)`).
+LINE.THROUGH_SYMBOL fails a line that cuts through a pump casing or an instrument bubble; a line may
+end on the outline, and filled dots (junctions, globe seats) belong to the line.
 
 Render loop: build, QA, render PNG, read the PNG, sweep dense sheets in a 3x2 tile, fix in
 the build, rebuild. Rebuilds stay byte-identical for unchanged inputs.

package/plugin/skills/lit-schematic/scripts/lib/qa-core.mjs

@@ -21,7 +21,7 @@ function kv(s) {
 export const CODES = [
   'TITLEBLOCK.FIELDS', 'LEGEND.COVERAGE', 'TAG.ORDER', 'LINE.NUMBER',
   'LINE.WEIGHT', 'LINE.ARROW_IN_SYMBOL', 'LINE.BEND_ON_LINE', 'LEADER.SPACING',
-  'LABEL.CLEARANCE',
+  'LABEL.CLEARANCE', 'SYMBOL.CONNECTED', 'LINE.THROUGH_SYMBOL',
 ];
 
 // ---- LABEL.CLEARANCE geometry: no label sits on another label or a line ----
@@ -88,13 +88,72 @@ function shrink(box) {
   return { x0: box.x0 + INSET, x1: box.x1 - INSET, y0: box.y0 + INSET, y1: box.y1 - INSET, label: box.label };
 }
 
+const AIR = 0.3; // a label keeps this much space from lines and outlines
+
+// Undo the label-to-label inset and add AIR all round.
+function air(box) {
+  const d = INSET + AIR;
+  return { x0: box.x0 - d, x1: box.x1 + d, y0: box.y0 - d, y1: box.y1 + d, label: box.label };
+}
+
+function pointSegDist(px, py, [x1, y1, x2, y2]) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const len = dx * dx + dy * dy;
+  const t = len ? Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / len)) : 0;
+  return Math.hypot(px - (x1 + t * dx), py - (y1 + t * dy));
+}
+
 function overlaps(a, b) {
   return a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1;
 }
 
-// Line, polyline and path segments as centerlines. Curves contribute only
-// their endpoints (rects and circles are checked by their edges, not needed
-// here): clearance is about labels struck by straight runs.
+// Circular arc (the kit draws rx = ry, no rotation) as short chords, from the
+// SVG endpoint parameterisation (SVG 1.1 F.6.5).
+function arcChords(x1, y1, r, large, sweep, x2, y2) {
+  const hx = (x1 - x2) / 2;
+  const hy = (y1 - y2) / 2;
+  const d2 = hx * hx + hy * hy;
+  if (!d2 || !r) return [[x1, y1, x2, y2]];
+  const rr = Math.max(Math.abs(r), Math.sqrt(d2));
+  const k = (large !== sweep ? 1 : -1) * Math.sqrt(Math.max(0, (rr * rr - d2) / d2));
+  const cx = k * hy + (x1 + x2) / 2;
+  const cy = -k * hx + (y1 + y2) / 2;
+  const a1 = Math.atan2(y1 - cy, x1 - cx);
+  let da = Math.atan2(y2 - cy, x2 - cx) - a1;
+  if (sweep && da < 0) da += 2 * Math.PI;
+  if (!sweep && da > 0) da -= 2 * Math.PI;
+  const out = [];
+  let [px, py] = [x1, y1];
+  for (let s = 1; s <= 12; s++) {
+    const a = a1 + (da * s) / 12;
+    const [nx, ny] = s === 12 ? [x2, y2] : [cx + rr * Math.cos(a), cy + rr * Math.sin(a)];
+    out.push([px, py, nx, ny]);
+    [px, py] = [nx, ny];
+  }
+  return out;
+}
+
+// Bezier (quadratic or cubic) as short chords.
+function bezierChords(pts) {
+  const out = [];
+  const at = (t) => {
+    let p = pts;
+    while (p.length > 1) p = p.slice(1).map((q, i) => [p[i][0] + (q[0] - p[i][0]) * t, p[i][1] + (q[1] - p[i][1]) * t]);
+    return p[0];
+  };
+  let prev = pts[0];
+  for (let s = 1; s <= 12; s++) {
+    const next = at(s / 12);
+    out.push([prev[0], prev[1], next[0], next[1]]);
+    prev = next;
+  }
+  return out;
+}
+
+// Line, polyline and path segments as centerlines; arcs and Bezier curves are
+// flattened into short chords so a label on a vent hood or an actuator dome is
+// caught too. Rects are checked by their edges; circles by circleHitsBox.
 function lineSegments(svg) {
   const segs = [];
   const push = (x1, y1, x2, y2) => {
@@ -138,11 +197,17 @@ function lineSegments(svg) {
         push(cx, cy, sx, sy);
         [cx, cy] = [sx, sy];
       } else if (/[ACSTQ]/i.test(cmd)) {
-        // Curves and arcs: only the endpoint matters for clearance.
         const count = /A/i.test(cmd) ? 7 : /C/i.test(cmd) ? 6 : 4;
         const nums = [];
         for (let k = 0; k < count && i < toks.length; k++) nums.push(Number(toks[i++]));
-        if (nums.length >= 2) [cx, cy] = nums.slice(-2);
+        if (nums.length < count) break;
+        let chords = [];
+        if (cmd === 'A') chords = arcChords(cx, cy, nums[0], nums[3] !== 0, nums[4] !== 0, nums[5], nums[6]);
+        else if (cmd === 'C') chords = bezierChords([[cx, cy], [nums[0], nums[1]], [nums[2], nums[3]], [nums[4], nums[5]]]);
+        else if (cmd === 'Q') chords = bezierChords([[cx, cy], [nums[0], nums[1]], [nums[2], nums[3]]]);
+        else chords = [[cx, cy, ...nums.slice(-2)]]; // S and T: the kit never emits them; keep the chord
+        for (const [a, b, c, d] of chords) push(a, b, c, d);
+        [cx, cy] = nums.slice(-2);
       }
     }
   }
@@ -156,6 +221,29 @@ function lineSegments(svg) {
   return segs;
 }
 
+// Every <circle>: bubbles, pump casings, motor and seat dots.
+function circles(svg) {
+  const out = [];
+  for (const m of svg.matchAll(/<circle\b([^>]*)\/>/g)) {
+    const get = (name) => Number((m[1].match(new RegExp(`\\b${name}="([\\d.]+)"`)) ?? [])[1]);
+    const fill = (m[1].match(/\bfill="([^"]+)"/) ?? [])[1] ?? 'none';
+    const c = { cx: get('cx'), cy: get('cy'), r: get('r'), filled: fill !== 'none' && fill !== '#fff' && fill !== '#ffffff' };
+    if (Number.isFinite(c.cx + c.cy + c.r) && c.r > 0) out.push(c);
+  }
+  return out;
+}
+
+// A label strikes a circle when the circle's disc reaches into the label box
+// but the box is not wholly inside the circle: a bubble's own letters sit
+// inside and pass; a tag across the outline, or a dot inside a word, fails.
+function circleHitsBox({ cx, cy, r }, box) {
+  const nx = Math.min(Math.max(cx, box.x0), box.x1);
+  const ny = Math.min(Math.max(cy, box.y0), box.y1);
+  if (Math.hypot(nx - cx, ny - cy) >= r) return false;
+  const far = Math.hypot(Math.max(Math.abs(box.x0 - cx), Math.abs(box.x1 - cx)), Math.max(Math.abs(box.y0 - cy), Math.abs(box.y1 - cy)));
+  return far > r;
+}
+
 function segHitsBox(x1, y1, x2, y2, box) {
   if (x1 >= box.x0 && x1 <= box.x1 && y1 >= box.y0 && y1 <= box.y1) return true;
   if (x2 >= box.x0 && x2 <= box.x1 && y2 >= box.y0 && y2 <= box.y1) return true;
@@ -230,11 +318,31 @@ export function runQA(svg) {
       }
     }
   }
+  const runs = lineSegments(svg);
+  // A vent is a pipe end: its leg must start on a nozzle, a vessel or a pipe.
+  for (const c of comments(svg, 'symbol')) {
+    const v = kv(c);
+    if (v.kind !== 'vent' || !v.at) continue;
+    const [vx, vy] = v.at.split(',').map(Number);
+    const own = ([x1, y1, x2, y2]) => x1 === vx && y1 === vy && x2 === vx && y2 < vy;
+    const touches = runs.some((s) => !own(s) && pointSegDist(vx, vy, s) <= 0.3);
+    if (!touches) fails.push({ code: 'SYMBOL.CONNECTED', msg: `vent at ${vx},${vy} floats: its leg meets no nozzle, vessel or pipe` });
+  }
+  // A line may end on a pump casing or an instrument bubble but never cut
+  // through one. Filled dots (junctions, globe seats) are part of the line.
+  for (const c of circles(svg).filter((c) => c.r >= 2 && !c.filled)) {
+    const outside = (x, y) => Math.hypot(x - c.cx, y - c.cy) > c.r + 0.5;
+    const hit = runs.find((s) => outside(s[0], s[1]) && outside(s[2], s[3]) && pointSegDist(c.cx, c.cy, s) < c.r - 0.5);
+    if (hit) fails.push({ code: 'LINE.THROUGH_SYMBOL', msg: `a line from ${hit[0]},${hit[1]} to ${hit[2]},${hit[3]} cuts through the circle at ${c.cx},${c.cy}` });
+  }
   if (!fails.some((f) => f.code === 'LABEL.CLEARANCE')) {
-    const runs = lineSegments(svg);
-    for (const box of labels) {
+    const rings = circles(svg);
+    // Against lines and circles a label needs air: touching a wall or a signal
+    // line reads as a collision, so the box grows instead of shrinking here.
+    for (const box of labels.map(air)) {
       const hit = runs.find(([x1, y1, x2, y2]) => segHitsBox(x1, y1, x2, y2, box));
       if (hit) fails.push({ code: 'LABEL.CLEARANCE', msg: `“${box.label}” sits on a line` });
+      else if (rings.some((c) => circleHitsBox(c, box))) fails.push({ code: 'LABEL.CLEARANCE', msg: `“${box.label}” sits on a circle` });
     }
   }
   return { pass: fails.length === 0, fails };

package/plugin/skills/lit-schematic/scripts/lib/sheet.mjs

@@ -97,8 +97,8 @@ export function createSheet(opts = {}) {
     const rows = 'ABCDEF';
     for (let i = 0; i < 6; i += 1) {
       const y = FRAME + ((SHEET_H - FRAME * 2) * (i + 0.5)) / 6;
-      out.push(text(FRAME - 2, y + 2, rows[i], { size: 6, anchor: 'middle' }));
-      out.push(text(SHEET_W - FRAME + 2, y + 2, rows[i], { size: 6, anchor: 'middle' }));
+      out.push(text(FRAME - 2.6, y + 2, rows[i], { size: 6, anchor: 'middle' }));
+      out.push(text(SHEET_W - FRAME + 2.6, y + 2, rows[i], { size: 6, anchor: 'middle' }));
     }
     out.push(el('line', { x1: FRAME, y1: BAND_BOTTOM, x2: SHEET_W - FRAME, y2: BAND_BOTTOM, stroke: INK, 'stroke-width': WEIGHTS.utility }));
     out.push(el('line', { x1: FRAME, y1: FIELD_TOP, x2: SHEET_W - FRAME, y2: FIELD_TOP, stroke: INK, 'stroke-width': WEIGHTS.utility }));
@@ -138,8 +138,8 @@ export function createSheet(opts = {}) {
   const thumb = (kind, x, y) => {
     const s = [];
     if (kind === 'tank') {
-      s.push(el('rect', { x: x - 6, y: y - 6, width: 12, height: 12, fill: '#fff', stroke: INK, 'stroke-width': WEIGHTS.utility }));
-      s.push(el('path', { d: `M ${x - 6} ${y - 6} L ${x + 6} ${y - 6} L ${x} ${y - 10} Z`, fill: 'none', stroke: INK, 'stroke-width': WEIGHTS.utility }));
+      s.push(el('rect', { x: x - 5, y: y - 4, width: 10, height: 9, fill: '#fff', stroke: INK, 'stroke-width': WEIGHTS.utility }));
+      s.push(el('path', { d: `M ${x - 5} ${y - 4} L ${x + 5} ${y - 4} L ${x} ${y - 6} Z`, fill: 'none', stroke: INK, 'stroke-width': WEIGHTS.utility }));
     } else if (kind === 'pump') {
       s.push(el('circle', { cx: x, cy: y, r: 6, fill: '#fff', stroke: INK, 'stroke-width': WEIGHTS.utility }));
       s.push(el('path', { d: `M ${x - 3} ${y - 3} L ${x - 3} ${y + 3} L ${x + 3} ${y} Z`, fill: INK }));
@@ -152,7 +152,8 @@ export function createSheet(opts = {}) {
     } else if (kind.startsWith('filter')) {
       s.push(el('path', { d: `M ${x} ${y - 6} L ${x + 6} ${y} L ${x} ${y + 6} L ${x - 6} ${y} Z`, fill: '#fff', stroke: INK, 'stroke-width': WEIGHTS.utility }));
     } else if (kind === 'psv') {
-      s.push(el('path', { d: `M ${x - 4} ${y + 6} L ${x - 4} ${y - 2} L ${x - 1} ${y} L ${x + 2} ${y - 4} L ${x + 5} ${y} L ${x + 5} ${y - 6} L ${x + 9} ${y - 2}`, fill: 'none', stroke: INK, 'stroke-width': WEIGHTS.utility }));
+      s.push(el('path', { d: `M ${x} ${y + 1} L ${x - 2.5} ${y + 6} L ${x + 2.5} ${y + 6} Z M ${x} ${y + 1} L ${x + 5} ${y - 1.5} L ${x + 5} ${y + 3.5} Z`, fill: '#fff', stroke: INK, 'stroke-width': WEIGHTS.utility }));
+      s.push(el('path', { d: `M ${x} ${y + 1} L ${x} ${y - 1} L ${x + 2} ${y - 2} L ${x - 2} ${y - 3.5} L ${x + 2} ${y - 5} L ${x} ${y - 6}`, fill: 'none', stroke: INK, 'stroke-width': WEIGHTS.utility }));
     } else if (kind === 'orifice') {
       s.push(el('line', { x1: x - 4, y1: y - 4, x2: x + 4, y2: y - 4, stroke: INK, 'stroke-width': WEIGHTS.process }));
       s.push(el('line', { x1: x - 2, y1: y - 5, x2: x - 2, y2: y + 5, stroke: INK, 'stroke-width': WEIGHTS.process }));
@@ -179,16 +180,18 @@ export function createSheet(opts = {}) {
     out.push(text(LEGEND_X, FIELD_TOP + 8, 'LEGEND', { size: 8 }));
     let y = FIELD_TOP + 22;
     // Two columns of 64: the widest thumbnail (relief zigzag, off-page hexagon)
-    // ends 12 past its origin, so labels start at +15 and the longest name still
-    // clears the next column's thumbnails.
+    // ends 12 past its origin; thumbnails sit 6 in from the panel rule so a pump
+    // circle clears it, labels start at +18, and the longest name still
+    // clears the next column's thumbnails. Rows sit 13 apart so the tallest
+    // thumbnails (pump circle, tank roof) never touch the row above or below.
     for (const [index, kind] of [...kinds].sort().entries()) {
       const col = index < Math.ceil([...kinds].length / 2) ? 0 : 1;
-      const yy = y + (index % Math.ceil([...kinds].length / 2)) * 11;
+      const yy = y + (index % Math.ceil([...kinds].length / 2)) * 13;
       const xx = LEGEND_X + col * 64;
-      out.push(thumb(kind, xx + 3, yy - 2));
-      out.push(text(xx + 15, yy, kindName(kind), { size: 6 }));
+      out.push(thumb(kind, xx + 6, yy - 2));
+      out.push(text(xx + 18, yy, kindName(kind), { size: 6 }));
     }
-    y += Math.ceil([...kinds].length / 2) * 11 + 6;
+    y += Math.ceil([...kinds].length / 2) * 13 + 6;
     const lineSample = (yy, weight, dash, name) => {
       out.push(el('line', { x1: LEGEND_X, y1: yy - 2, x2: LEGEND_X + 14, y2: yy - 2, stroke: INK, 'stroke-width': weight, ...(dash ? { 'stroke-dasharray': dash } : {}) }));
       out.push(text(LEGEND_X + 18, yy, name, { size: 6 }));
@@ -223,8 +226,10 @@ export function createSheet(opts = {}) {
     const x = best.x1 + (best.x2 - best.x1) * at;
     const y = best.y1 + (best.y2 - best.y1) * at;
     const vertical = best.x1 === best.x2;
+    // Rotated -90, the glyph tops face the pipe: a baseline 8 out leaves about
+    // 3.7 mm of air, the same as a horizontal number riding 4 above its line.
     return vertical
-      ? el('text', { x: x + 5, y, 'font-size': 6, 'font-family': 'Arial, sans-serif', fill: INK, transform: `rotate(-90 ${x + 5} ${y})`, 'data-clear': 'true' }, number)
+      ? el('text', { x: x + 8, y, 'font-size': 6, 'font-family': 'Arial, sans-serif', fill: INK, transform: `rotate(-90 ${x + 8} ${y})`, 'data-clear': 'true' }, number)
       : text(x, y - 4, number, { size: 6, anchor: 'middle' });
   };
 
@@ -238,14 +243,17 @@ export function createSheet(opts = {}) {
       shapes.push(text(x, y + 14, label ?? id, { size: 7 }));
       return id;
     },
-    tank(tag, x, y) {
+    tank(tag, x, y, side = 'below') {
       kinds.add('tank');
       marks.push(comment(`symbol kind=tank id=${tag}`));
       shapes.push(el('path', { d: `M ${x - 22} ${y - 26} L ${x + 22} ${y - 26} L ${x} ${y - 40} Z`, fill: '#fff', stroke: INK, 'stroke-width': WEIGHTS.process }));
       shapes.push(el('rect', { x: x - 22, y: y - 26, width: 44, height: 52, fill: '#fff', stroke: INK, 'stroke-width': WEIGHTS.process }));
       shapes.push(el('rect', { x: x - 3, y: y - 46, width: 6, height: 6, fill: '#fff', stroke: INK, 'stroke-width': WEIGHTS.utility }));
       shapes.push(el('rect', { x: x - 3, y: y + 26, width: 6, height: 6, fill: '#fff', stroke: INK, 'stroke-width': WEIGHTS.utility }));
-      shapes.push(text(x + 10, y + 40, tag, { size: 7 }));
+      // 'right' puts the tag beside the shell at mid-height, clear of the bottom
+      // nozzle and of anything that hangs below the tank.
+      if (side === 'right') shapes.push(text(x + 26, y + 2, tag, { size: 7 }));
+      else shapes.push(text(x + 10, y + 40, tag, { size: 7 }));
       return tag;
     },
     pump(tag, x, y, side = 'below') {
@@ -262,21 +270,57 @@ export function createSheet(opts = {}) {
       else shapes.push(text(x, y + 26, tag, { size: 7, anchor: 'middle' }));
       return tag;
     },
-    strainer(id, x, y) {
+    strainer(id, x, y, orient = 'h', tagSide = 'left') {
       kinds.add('filter.strainer');
       marks.push(comment(`symbol kind=filter.strainer id=${id}`));
       shapes.push(el('path', { d: `M ${x} ${y - 7} L ${x + 7} ${y} L ${x} ${y + 7} L ${x - 7} ${y} Z`, fill: '#fff', stroke: INK, 'stroke-width': WEIGHTS.process }));
-      shapes.push(text(x, y + 18, id, { size: 7, anchor: 'middle' }));
+      // On a vertical pipe a tag below the diamond would sit on the pipe itself.
+      if (orient === 'v') shapes.push(text(tagSide === 'right' ? x + 10 : x - 10, y + 2.5, id, { size: 7, anchor: tagSide === 'right' ? 'start' : 'end' }));
+      else shapes.push(text(x, y + 18, id, { size: 7, anchor: 'middle' }));
       return id;
     },
-    psv(tag, x, y, set) {
+    // Angle body: an inlet triangle and an outlet triangle meet at (x, y), each
+    // with a 3-unit stem, so pipes connect 10 from the center: inlet below
+    // (x, y + 10) and outlet right (x + 10, y) by default. The spring rises
+    // opposite the inlet; the tag and set pressure sit opposite the outlet.
+    psv(tag, x, y, set, opts2 = {}) {
+      const DIRS = { right: [1, 0], left: [-1, 0], up: [0, -1], down: [0, 1] };
+      const outlet = opts2.outlet ?? 'right';
+      const inlet = opts2.inlet ?? (outlet === 'left' || outlet === 'right' ? 'down' : 'left');
+      const o = DIRS[outlet];
+      const n = DIRS[inlet];
+      if (!o || !n || o[0] * n[0] + o[1] * n[1] !== 0) {
+        throw new Error(`psv ${tag}: inlet ${inlet} and outlet ${outlet} must be at right angles`);
+      }
       kinds.add('psv');
-      marks.push(comment(`symbol kind=psv id=${tag}`));
-      shapes.push(el('line', { x1: x, y1: y + 10, x2: x, y2: y - 4, stroke: INK, 'stroke-width': WEIGHTS.process }));
-      shapes.push(el('path', { d: `M ${x} ${y - 4} L ${x + 3} ${y - 1} L ${x - 3} ${y + 2} L ${x + 3} ${y + 5} L ${x - 3} ${y + 8}`, fill: 'none', stroke: INK, 'stroke-width': WEIGHTS.utility }));
-      shapes.push(el('path', { d: `M ${x} ${y - 4} L ${x + 12} ${y - 4} L ${x + 12} ${y + 2} L ${x} ${y + 2}`, fill: 'none', stroke: INK, 'stroke-width': WEIGHTS.process }));
-      shapes.push(text(x + 14, y - 2, tag, { size: 6 }));
-      if (set) shapes.push(text(x + 14, y + 6, set, { size: 6 }));
+      marks.push(comment(`symbol kind=psv id=${tag} inlet=${inlet} outlet=${outlet}`));
+      const at = (v, d, w = [0, 0], e = 0) => [x + v[0] * d + w[0] * e, y + v[1] * d + w[1] * e].map((c) => Math.round(c * 100) / 100 + 0);
+      const P = (pt) => `${pt[0]} ${pt[1]}`;
+      const sp = [-n[0], -n[1]];
+      shapes.push(el('path', {
+        d: `M ${x} ${y} L ${P(at(n, 7, o, 3.5))} L ${P(at(n, 7, o, -3.5))} Z M ${x} ${y} L ${P(at(o, 7, n, 3.5))} L ${P(at(o, 7, n, -3.5))} Z`,
+        fill: '#fff', stroke: INK, 'stroke-width': WEIGHTS.process,
+      }));
+      for (const v of [n, o]) {
+        const [x1, y1] = at(v, 7);
+        const [x2, y2] = at(v, 10);
+        shapes.push(el('line', { x1, y1, x2, y2, stroke: INK, 'stroke-width': WEIGHTS.process }));
+      }
+      const zig = [at(sp, 3), at(sp, 4.5, o, 2.5), at(sp, 6.5, o, -2.5), at(sp, 8.5, o, 2.5), at(sp, 10.5, o, -2.5), at(sp, 12)];
+      shapes.push(el('line', { x1: x, y1: y, x2: zig[0][0], y2: zig[0][1], stroke: INK, 'stroke-width': WEIGHTS.utility }));
+      shapes.push(el('path', { d: `M ${zig.map(P).join(' L ')}`, fill: 'none', stroke: INK, 'stroke-width': WEIGHTS.utility }));
+      const t = [-o[0], -o[1]];
+      if (t[0]) {
+        const anchor = t[0] < 0 ? 'end' : 'start';
+        shapes.push(text(x + t[0] * 6, y - 4, tag, { size: 6, anchor }));
+        if (set) shapes.push(text(x + t[0] * 6, y + 3, set, { size: 6, anchor }));
+      } else if (t[1] > 0) {
+        shapes.push(text(x, y + 10, tag, { size: 6, anchor: 'middle' }));
+        if (set) shapes.push(text(x, y + 17, set, { size: 6, anchor: 'middle' }));
+      } else {
+        shapes.push(text(x, y - 13, tag, { size: 6, anchor: 'middle' }));
+        if (set) shapes.push(text(x, y - 6, set, { size: 6, anchor: 'middle' }));
+      }
       return tag;
     },
     orifice(id, x, y) {
@@ -307,12 +351,8 @@ export function createSheet(opts = {}) {
       }
       shapes.push(text(x, y - 1, letters, { size: 6, anchor: 'middle' }));
       shapes.push(text(x, y + 7, number, { size: 6, anchor: 'middle' }));
-      // A signal leaving the bubble at mid-height would strike a right-side tag,
-      // and a side tag can hit the next symbol; below or left keep it clear.
-      const place = opts2.tag ?? 'right';
-      if (place === 'below') shapes.push(text(x, y + r + 9, tag, { size: 6, anchor: 'middle' }));
-      else if (place === 'left') shapes.push(text(x - r - 3, y + 2, tag, { size: 6, anchor: 'end' }));
-      else shapes.push(text(x + r + 3, y + 2, tag, { size: 6 }));
+      // The bubble already reads as the tag (letters over number), so no second
+      // tag is printed beside it. The old `tag` placement option is accepted and ignored.
       return tag;
     },
     offpage(label, x, y, dir = 'out', w = 22) {
@@ -339,7 +379,7 @@ export function createSheet(opts = {}) {
     },
     vent(x, y) {
       kinds.add('vent');
-      marks.push(comment('symbol kind=vent id=ATM'));
+      marks.push(comment(`symbol kind=vent id=ATM at=${x},${y}`));
       shapes.push(el('path', { d: `M ${x} ${y} L ${x} ${y - 8} A 5 5 0 0 1 ${x + 10} ${y - 8} L ${x + 10} ${y - 2}`, fill: 'none', stroke: INK, 'stroke-width': WEIGHTS.utility }));
       // The label sits left of the vent pipe so it never touches the arc.
       shapes.push(text(x - 5, y - 1, 'ATM', { size: 6, anchor: 'end' }));
@@ -377,7 +417,7 @@ export function createSheet(opts = {}) {
       const [x2, y2] = pts[pts.length - 1];
       return api.add(kind, id, x1 + (x2 - x1) * at, y1 + (y2 - y1) * at, id);
     },
-    valve(body, actuator, id, x, y, fail = 'FC', orient = 'h') {
+    valve(body, actuator, id, x, y, fail = 'FC', orient = 'h', tagSide = 'left') {
       kinds.add(`valve.${body}.${actuator}`);
       marks.push(comment(`symbol kind=valve.${body}.${actuator} id=${id} fail=${fail}`));
       const v = orient === 'v';
@@ -408,12 +448,23 @@ export function createSheet(opts = {}) {
         }
       }
       if (body !== 'check' || fail !== 'FC') shapes.push(text(x + 8, y - 6, fail, { size: 6 }));
-      shapes.push(text(v ? x : x - 6, y + (v ? 16 : 14), id, { size: 7, anchor: 'middle' }));
+      // On a vertical pipe a tag below the body would sit on the pipe, so it goes
+      // beside it: left by default, or right past the actuator (and fail letters).
+      if (v && tagSide === 'right') shapes.push(text(x + (body === 'check' ? 7 : 15), y + 2.5, id, { size: 7, anchor: 'start' }));
+      else if (v) shapes.push(text(x - 7, y + 2.5, id, { size: 7, anchor: 'end' }));
+      else shapes.push(text(x - 6, y + 14, id, { size: 7, anchor: 'middle' }));
       return id;
     },
-    arrow(x, y, clear = true) {
-      marks.push(comment(`arrow at=${x},${y} clear=${clear ? 'true' : 'false'}`));
-      shapes.push(el('path', { d: `M ${x - 4} ${y - 2} L ${x} ${y} L ${x - 4} ${y + 2}`, fill: 'none', stroke: INK, 'stroke-width': WEIGHTS.process }));
+    // An open chevron with its tip at (x, y), pointing the way the flow runs.
+    arrow(x, y, clear = true, dir = 'right') {
+      const wings = {
+        right: [[-4, -2], [-4, 2]], left: [[4, -2], [4, 2]],
+        up: [[-2, 4], [2, 4]], down: [[-2, -4], [2, -4]],
+      }[dir];
+      if (!wings) throw new Error(`arrow direction ${dir} is not right, left, up or down`);
+      marks.push(comment(`arrow at=${x},${y} clear=${clear ? 'true' : 'false'} dir=${dir}`));
+      const [[ax, ay], [bx, by]] = wings;
+      shapes.push(el('path', { d: `M ${x + ax} ${y + ay} L ${x} ${y} L ${x + bx} ${y + by}`, fill: 'none', stroke: INK, 'stroke-width': WEIGHTS.process }));
     },
     hop(x, y, r = 1.5) {
       marks.push(comment(`hop r=${r}`));