---
name: commune-drop-dir-info-cwd
description: "Commune drop dir = info.cwd joined with .claude — a worktree .claude/ is STRUCTURALLY unreachable (spt-daemon/src/lifecycle.rs:769/872 + spt-live/src/ingest.rs:247/259, info.json on disk). SETTLED AT SOURCE 2026-08-25 after two probe rounds and a self-retraction: before probing a behaviour, check whether you can READ it — a missing read VERB is not a missing read."
metadata: 
  node_type: memory
  type: project
  originSessionId: d780a4d4-c7b1-44a2-818b-9d5f41a0eb4e
  modified: 2026-08-29T02:33:29.146Z
---

**Mechanism (doyle-ruled 9(e), CLOSED-mechanism / OPEN-fix, re-measured by chert + me at 8f3e10b):** the commune watch is per-endpoint, resolved against the endpoint's recorded `info.cwd` — `reporting.rs:686-698` joins a RELATIVE `commune_dir` with no base; `lifecycle.rs` `fire_echo` ~L859-866 supplies `read_info().cwd`; `lifecycle.rs:212` joins `endpoint_cwd` for relative paths. Fix is doyle's to dispatch, grill-scoped.

**Observability gap under it:** NO read verb exposes `info.cwd` (`endpoint list --json` → zero cwd fields). An agent cannot check where its own commune must land. Roster string is a derived LABEL, not the field.

**Census (doyle + deployah independent, 2026-07-30):** depth-1 glob under `~/Documents/projects/*/.claude/` → 22 dirs, commune drops = 5, signoff drops = 0. flynn ×2 (spt-core 307 B @2026-07-10T04:25:06Z, spt-mobile 1747 B @2026-07-14T01:16:01Z), perri ×2 (omp-spt, spt-claude-code), rc-exit-probe ×1 (on no endpoint = orphan, not live loss). **deployah's orphan proof needs no info.cwd:** one endpoint = at most one resolved drop dir ⇒ two drops in two dirs = ≥1 orphaned certainly; total ≥3 certain, ≤5. flynn notified by me 2026-07-30 (QUEUED).

**Why:** communes silently orphan when an endpoint's recorded cwd differs from where the agent writes; a healthy-looking resume does NOT prove consumption (flynn's correction — periodic Psyche save fakes it).

**How to apply:** verify own drop dir with flynn's nonce sentinel (unique nonce in commune body, check next brief for that exact nonce; absent-while-context-returns = wrong dir). Doyle authorized self-use; fleet standardisation waits for the grill. Lessons banked with it: THE SCAN ROOT IS THE POPULATION (doyle's census inherited the base-path defect it was investigating, one level up); when a premise is unmeasurable, look for the argument that doesn't need it; census of a live queue is `>=` at an instant (doyle observed a 6th drop consumed within seconds — ingest on a MATCHING dir completes fast); quote the mtime not the age — `ls -l` prints LOCAL (UTC-7 here), all traded stamps are UTC, naive compare overstates ages 7h. See [[psyche-fail-log-instrument]], [[v0460-published]].

---

**ROUND 1-3, todlando @HFENDULEAM, 2026-08-25 — PRACTICE settled, MECHANISM not.** Write the commune
to the **MAIN project root `.claude/`**. A drop in a WORKTREE's `.claude/` does not demonstrably reach
the mind. That is the safe practice and it is all that is established.

**I over-ruled this once and falsified it myself the same hour. The retracted claim:** "worktree drops
orphan silently; decided by three legs." Two of the three legs died on re-measurement:

- **Leg 1 (file state / ordering) is DEAD, and I killed the instrument.** The argument was "main copy
  consumed, worktree copy left." Its ordering needed the worktree copy's write time against the brief
  route (23:11:17). `ls -la` gives MINUTE granularity — 23:11 — which straddles the route, and I had
  already destroyed the sub-minute truth by preserving the file with `cp` instead of `cp -p`. **A
  preservation copy that does not carry `-p` destroys the timestamp it was made to preserve.**
- **Leg 2 (content identity) never discriminated** — both copies carried byte-identical bodies.
- **Leg 3 (a 5-day-old unconsumed worktree drop) survives, and is now the ONLY leg.**

**RIVAL EXPLANATION I had not tested, and it is live:** ingest can FAIL and leave the file sitting on
disk, which is indistinguishable from an orphan by looking at the directory. Measured, not supposed:
`logs/daemon.stderr.log` carries 6 `PSYCHE_INGEST_FAIL` — **todlando x4, deployah x1, doyle x1**, NOT six mine (doyle corrected me first-hand; I ran a bare `grep -c` and attached the POPULATION count to the one id I was hunting, which concentrated the damage on me and read as more careful than it was) — one at **23:12:03 today**, all
`git index.lock` / `cannot lock ref HEAD` contention in the SHARED project seed worktree
(`tracked/.seed.git/worktrees/github-com-bigscreenvr-spt-bs-core`) — todlando and deployah ingesting
concurrently collide. **⚠ ATTRIBUTION UNREPRODUCED (corrected 2026-08-29, todlando + IR-68):** the
log LINES carrying lock-error text are the measurement; the CAUSAL claim "a held index.lock makes
ingest fail" is refuted at the seam — `crates/spt-daemon/tests/commune_io_events_int.rs` planted
non-empty locks in BOTH places git takes one (bare git-dir + every linked worktree lock), plant count
asserted, and ingest committed anyway reporting Written. The cause class behind the six failures is
OPEN (IR-68). Do not cite index.lock as an available fault-injection mechanism: the working induced
COMMUNE_FAIL for that seam is **replacing the drop FILE with a DIRECTORY** (the body read `?`-fails
before any tier is touched; helper lives in that rig). I cited the dead mechanism in a dispatch brief
2026-08-29 and todlando handed it back — the register (IR-68) knew better than this memory did. Failure is logged with a `strike 1/3` retry and is **never surfaced to the
agent**; the mind files were rewritten 5.5 min later, consistent with a retry. So **before reading a
surviving drop file as an orphan, grep the daemon log for `PSYCHE_INGEST_FAIL:<id>`.** FILED by doyle as **releases#221** (type bugfix, BACKLOG): per-project ingest serialization (wait, not fail) + surface terminal ingest failure to the agent, since silent strike-3 loss is unrecoverable when consumption looks identical to success. **The consumed-vs-landed seam already has ONE guarded arm** (doyle, from his own read): `spt-live/src/ingest.rs:223-246` documents F-032 commit-before-delete (KNOWN-HAZARDS 7.40, REQ-HAZARD-COMMUNE-INGEST-BLACKHOLE) — a non-empty project slice under an unresolved `project_id` is PRESERVED as a pending slice rather than black-holed, which is the `COMMUNE_PROJECT_DEFERRED` line the log shows for engine-room. #221 is the UNGUARDED arm: git-level failure INSIDE the commit, retried then silent. So "the drop file survived" has three readings now, not two — orphan, deferred-by-design, or failed ingest — and only the log separates them: `COMMUNE_PROJECT_DEFERRED:<id>` for deferred, `PSYCHE_INGEST_FAIL:<id>` for failed, and **DOUBLE SILENCE — BOTH markers absent — SUPPORTS orphan** (doyle’s correction to my form: orphan is not read off one absent marker, and "supports" is the strength absence earns, never "proves"). #221 scopes to the failed arm only; the deferred arm is the guard WORKING and is not a defect. Extends [[commune-ingest-dies-silently]].

**doyle's untagged-tier scope note — SETTLED by reading disk, no probe.** My "untagged text does not
arrive at all" was measured at the BRIEF, a COMPOSED surface, and could not distinguish dropped from
stored-but-not-surfaced. The mind is readable directly at
`%LOCALAPPDATA%/spt-core/tracked/agents/<id>/live-context.md` and
`tracked/projects/<proj>/<id>/project-context.md`. Result: the untagged preamble’s nonces ARE in
the mind — so ingest does **not** drop untagged text. They landed in the **PROJECT** tier, not the
live tier the perch doc names. Note the store is a **summariser rewrite**, not the verbatim body,
while the brief carried the tagged sections VERBATIM — **the brief is not a render of the mind's tier
files**, so a claim about one is not a claim about the other.

**How to apply:** (i) drop the commune in the MAIN project `.claude/`; (ii) a nonce belongs INSIDE
`<project-context>` — preamble is not a readable channel at the brief; (iii) read the TIER FILES on
disk, not the brief, whenever the question is what was stored; (iv) a surviving drop file is
orphan-OR-failed-ingest until the daemon log says which; (v) probe with a SINGLE copy — two copies
with identical bodies cannot tell you which was consumed; (vi) `cp -p`, always, when the copy is
evidence. See [[dont-take-a-diagnosis-as-measured]], [[commune-ingest-dies-silently]],
[[identical-readings-across-opposite-outcomes-indict-the-meter]].

**SETTLED AT THE SOURCE, 2026-08-25 - and the source was in the repo I work in the whole time.**
Two probe rounds and a retraction were spent on a question the product answers by construction:

- `spt-daemon/src/lifecycle.rs:769` `drop_dirs()` yields exactly the endpoint's `commune_dir` +
  `signoff_dir` (both `.claude` under claude-spt) - a two-element list, not a search.
- `lifecycle.rs:872` sweeps them through `resolve_endpoint_drop_dir(raw, cwd_path)`; a RELATIVE dir
  resolves to `cwd.join(".claude")` against the endpoint's FRESH `info.cwd`, and a relative dir with
  NO recorded cwd is SKIPPED loud-once, never guessed (its own unit test at `lifecycle.rs:2869`
  states all four cases).
- `spt-live/src/ingest.rs:247` `ingest_drops(drop_dir, id, ...)` then joins exactly
  `{id}-commune.md` in that ONE dir (`:259`) - no recursion, no scan, `exists()` or `continue`.
- My `info.cwd`, read straight off disk at `%LOCALAPPDATA%/spt-core/owlery/<id>/info.json`, is
  the MAIN project root `C:/Users/decid/Documents/projects/spt-core`.

So a worktree `.claude/` is **structurally unreachable**: never opened, never read. That also
ELIMINATES the failed-ingest rival for worktree files specifically - a file that is never read
cannot fail an ingest - and explains the 5-day keystone-w1 orphan with no inference at all.

Positive control anyway: round-3's single-copy drop sat ~6 min (~70 pulses at the 5s
`DEFAULT_PULSE_PERIOD`) untouched, zero nonces in the tier files, zero new `PSYCHE_INGEST_FAIL`.
Removed after reading.

**The real lesson, and it is not about commune dirs:** I ran two instrumented probe rounds, published
a three-leg ruling, and retracted two legs - against a product whose source and unit tests sit in the
repo I was standing in. **Before probing a behaviour, check whether you can READ it.** The
observability gap (`info.cwd` exposed by no read verb) is real and is what pushed me to probe, but
the JSON is on disk and the call chain is four greps long. **A missing read VERB is not a missing
read.**