Teach the remote shim the Artifactory's five verbs

[scgopi]

Closes #281.

A loop on an ssh:// or Codespaces host is handed the briefing's full "The Artifactory — notes for whoever comes next" section, told to check the board at the start of every pass, and then refused by its CLI on all five verbs. Its own node sends are mirrored onto that board by the daemon, so a remote loop was not absent from the Artifactory — it was write-only and blind: visible to every peer, unable to read a word anyone said back.

Shim-only, as #281 established

No DaemonProtocol, RemoteSocketForwarder, GraphStore or SessionBriefing change. read and list send no command at all — openProject's graphChanged snapshot already carries the whole board and every node's lastArtifactoryRead.

Verb	How it works
post	one artifactoryPost frame; prints posted #N (topic) from the returned graph
sync	artifactorySync, rendered from the snapshot taken before the cursor moves; --headlines --full --mark --json, same precedence as the Swift CLI
read	snapshot only, no command
list	snapshot only; --search --json
watch	one artifactoryWatch frame; --topic --off

sync and watch refuse a human shell up front in the Swift CLI's own wording, before dialling, so nothing is sent and nothing needs undoing.

Plus the sixth gap from the issue: the shim's render(graph) omitted the board status line the local CLI appends (renderArtifactoryStatusLine), so graphcode status hid the board from a remote loop even with the snapshot in hand. Fixed here.

The risk, and what answers it

This adds a second copy of the renderer — Python, inside the shim — and cliShimStamp is content-derived, so a defective shim propagates to every remote host on the next ensure and silently breaks node send and memo for every loop already running there.

What makes that safe is RemoteCLIShimTests asserting the two byte-equal, to the standard PR #275 set in CodexReadinessGateTests: a real socket, the production cliShimSource executed as delivered, and every expected value computed by calling GraphcodeCommand's own renderer — never a string written by hand. 13 new tests, 18 in the suite.

The parity test earned its keep twice, on drift I would not have found by reading:

1. The reference-date offset is invisible in the stamp. 978307200 seconds is exactly 11323 days, which is exactly 31 years across the fixture's eight leap days — so a shim that dropped the offset renders an identical MMM d, HH:mm (Aug 23, 18:46 either way). The stamp alone can never catch it. The year is pinned through --json's ISO-8601 instead, where the mistake is unmissable.
2. Swift's JSONEncoder escapes / as \/; json.dumps does not. The first fixture had no slash in any body, so the test passed while --json was genuinely wrong. Caught by the live check below, then fixed and pushed back into the fixture, which now carries a path and a URL. Reverting the fix fails the test — verified.

Also pinned: the 12-post / 4096-byte triage boundary on both sides and both directions; the identity refusals; that read/list send nothing past the open; and that artifactory no longer reaches the "Mac-only" refusal.

Verification

Not verified: an end-to-end run on a real remote host or Codespace. I had none available. Everything below ran locally against the same daemon socket the ssh forward carries, and the byte-equal parity is what this PR stands on.

Beyond the suite, the delivered shim source was extracted and run against the live daemon socket on the real project board (136 posts), diffed against the real Swift CLI:

Command	Result
artifactory list <path>	✅ byte-identical
artifactory list --json	✅ byte-identical (after the \/ fix — this is where it was found)
artifactory list --search release / --search 0.1.59 / no match	✅ byte-identical
artifactory read <id> (present, and #999 absent)	✅ byte-identical, same exit code
status <path> board line	✅ identical (artifactory: 131 posts)

status still differs from the local CLI in the pre-existing ways — the shim renders no edges block and no attention/exit-code suffixes. Out of scope here; the board line itself matches.

Gate: 1573 tests pass, swiftlint 0 errors, swift format --strict clean, all three schemes (graphcode, graphcode-cli, graphcoded) build.

Independent review

Reviewed by a separate loop (ReviewPR282, OpenCode backend) against b248f1a, which re-ran the gate in its own worktree and confirmed 1573 tests pass, swiftlint 0 errors, swift format --strict clean, all three schemes building. Verdict: approve with notes, no blocking defects.

It verified the parity harness runs the production cliShimSource under python3 against a real AF_UNIX socket serving production graphChanged frames, with every expected value produced by the real GraphcodeCommand renderer — no hand-written renderer literals. It independently re-ran the live diff against the installed CLI on the real board, covering 63 non-ASCII bodies including a CJK post, and confirmed the \/ escaping match.

One divergence found, currently unobservable: the shim trims a note with Python .strip() (all Unicode whitespace) where Swift uses .whitespaces (space and tab only). It cannot be observed today because the daemon re-trims with .whitespacesAndNewlines on arrival (GraphStore.swift:1594) — but it is a latent trap if that store-side trim ever changes.

Recommended post-merge check: stamp propagation to a real host on first ensure, and live remote sync/watch attribution via ZMX_SESSION, remain unproven here — both are pre-existing machinery rather than shim logic. The first remote ensure after this merges should be watched once.

Known limits, deliberately not fixed

• watch delivery inherits node send's remote deliverability. A remote Codex turn-based loop will post, sync, read and list fine and miss only watch dings until Remote send gate silently drops messages to an attended Codex loop: pane-created sessions carry no readiness proof #278 lands. Neither fixed nor worsened here.
• Grapheme vs code point. renderHeadline's 80-character budget counts grapheme clusters in Swift and code points in Python, so a body built from combining sequences could cut a character differently. Noted in the shim; everything else about the line is identical.
• Attribution is not authentication, and one board per workspace — both unchanged from Artifactory is unreachable from remote/Codespaces loops: the briefing teaches five verbs the shim refuses #281's analysis.

🤖 Generated with Claude Code

https://claude.ai/code/session_01AoU8LMupkqeoemNSob7VuM

[scgopi]

Review round 1 applied

All five findings addressed, each pinned by a test that fails when the fix is reverted (verified — reverting all four code fixes fails 16 assertions across 3 tests).

#	Finding	Fix
1	--search normalization-sensitive	both needle and haystack fold through unicodedata.normalize("NFC", …) before the substring test
2	headline cut counts code points	UAX #29 reduced to the joins that reach a note — combining marks, ZWJ, variation selectors, skin-tone modifiers, regional-indicator flags
3	a --flag accepted as the project path	refused before the dial, matching parseArtifactory's take
4	empty-string topic rendered without ()	is not None, matching Swift's Optional map
5	doc comment said 14.6 KB shim	now 31 KB

On #2 in particular — the review was right that the PR undersold it, and it turned out to be fixable rather than merely documentable. headlinesCutAtTheSameGraphemeClusterTheMacDoes drives six bodies through both renderers and asserts byte equality: 70 decomposed a+U+0301, 20 ZWJ families, skin-tone + flag + keycap sequences, a mixed body whose cut lands mid-sequence, astral non-joining, and plain ASCII. All byte-equal. The remaining approximation is Hangul jamo composition, which no note has ever contained.

On #4: agreed it is unreachable through the daemon today. Fixed anyway for the reason the finding gives — the renderer should not carry a second opinion about a rule that lives in GraphStore.

Gate re-run: 1573 tests pass (3 new), swiftlint 0 errors, swift-format strict clean, all three schemes build. Live diff against the real CLI on the now-132-post board re-confirmed byte-identical for list, list --json, --search, read, and the status board line.

Still unverified, unchanged from the PR body: no end-to-end run on a real remote host or Codespace — I have none available.

🤖 Generated with Claude Code

https://claude.ai/code/session_01AoU8LMupkqeoemNSob7VuM