@junghanacs/entwurf 0.12.8 → 0.12.10

package/scripts/check-meta-listing.ts

@@ -16,11 +16,19 @@
  *   - mode "strict" throws on any error; "collect" (default) returns partial,
  *   - errors sorted by filename.
  *
+ * #52 adds the store-WIDE half this listing can afford (it already holds every
+ * record): two records claiming one `nativeSessionId` are not two citizens. NEITHER
+ * is listed — a facts surface may not mint the ownership the certification refuses
+ * to mint — both become errors naming each other, and every unrelated citizen keeps
+ * listing. Before this, `entwurf_peers` reported a store the doctor calls
+ * uncertifiable as clean, which is a wrong FACT, not merely a missing guard.
+ *
  * Pure; entries/readRecord injected, no IO.
  */
 
 import assert from "node:assert/strict";
 import {
+	type ActiveStoreEntry,
 	listAllMetaIdentities,
 	type MetaCitizenBackend,
 	type MetaIdentity,
@@ -61,10 +69,17 @@ function reader(map: Record<string, string>): (filename: string) => string {
 	};
 }
 
+/** Store entries from a fixture map — every name a REGULAR file unless `irregular` says
+ * otherwise. The listing takes kind, not bare names, so rule 1 (a symlinked record is
+ * refused and never followed) is enforceable on this surface too. */
+function entries(map: Record<string, string>, irregular: readonly string[] = []): ActiveStoreEntry[] {
+	return Object.keys(map).map((filename) => ({ filename, regularFile: !irregular.includes(filename) }));
+}
+
 // ── valid records → identities, sorted ──────────────────────────────────────
 {
 	const map = { [`${GID_B}.meta.json`]: rec(GID_B), [`${GID_A}.meta.json`]: rec(GID_A) };
-	const { identities, errors } = listAllMetaIdentities(Object.keys(map), reader(map));
+	const { identities, errors } = listAllMetaIdentities(entries(map), reader(map));
 	ok("2 valid → 2 identities, 0 errors", identities.length === 2 && errors.length === 0);
 	ok("identities sorted by gardenId", identities[0]?.gardenId === GID_A);
 }
@@ -72,7 +87,7 @@ function reader(map: Record<string, string>): (filename: string) => string {
 // ── corrupt record does NOT blind the listing ───────────────────────────────
 {
 	const map = { [`${GID_A}.meta.json`]: rec(GID_A), [`${GID_B}.meta.json`]: "{ broken json" };
-	const { identities, errors } = listAllMetaIdentities(Object.keys(map), reader(map));
+	const { identities, errors } = listAllMetaIdentities(entries(map), reader(map));
 	ok("corrupt 1 → valid still listed (not blinded)", identities.length === 1 && identities[0]?.gardenId === GID_A);
 	ok("corrupt → exactly 1 error", errors.length === 1);
 	ok("error names the corrupt file", errors[0]?.filename === `${GID_B}.meta.json`);
@@ -81,7 +96,7 @@ function reader(map: Record<string, string>): (filename: string) => string {
 // ── body/filename drift → error, excluded ───────────────────────────────────
 {
 	const map = { [`${GID_A}.meta.json`]: rec(GID_B) }; // filename A, body claims B
-	const { identities, errors } = listAllMetaIdentities(Object.keys(map), reader(map));
+	const { identities, errors } = listAllMetaIdentities(entries(map), reader(map));
 	ok("drift → excluded from identities", identities.length === 0);
 	ok("drift → 1 error mentioning drift", errors.length === 1 && /drift/.test(errors[0]?.message ?? ""));
 }
@@ -92,21 +107,27 @@ function reader(map: Record<string, string>): (filename: string) => string {
 		if (f === `${GID_B}.meta.json`) throw new Error("ENOENT mid-scan");
 		return rec(GID_A);
 	};
-	const { identities, errors } = listAllMetaIdentities([`${GID_A}.meta.json`, `${GID_B}.meta.json`], read);
+	const { identities, errors } = listAllMetaIdentities(
+		[
+			{ filename: `${GID_A}.meta.json`, regularFile: true },
+			{ filename: `${GID_B}.meta.json`, regularFile: true },
+		],
+		read,
+	);
 	ok("reader throw → error, valid still listed", identities.length === 1 && errors.length === 1);
 }
 
 // ── non-.meta.json ignored ──────────────────────────────────────────────────
 {
 	const map = { [`${GID_A}.meta.json`]: rec(GID_A), "README.txt": "x", "inbox.signal": "y" };
-	const { identities, errors } = listAllMetaIdentities(Object.keys(map), reader(map));
+	const { identities, errors } = listAllMetaIdentities(entries(map), reader(map));
 	ok("non-.meta.json entries ignored", identities.length === 1 && errors.length === 0);
 }
 
 // ── verbatim-or-nothing: error keyset = {filename, message} ─────────────────
 {
 	const map = { [`${GID_A}.meta.json`]: "{ broken" };
-	const { errors } = listAllMetaIdentities(Object.keys(map), reader(map));
+	const { errors } = listAllMetaIdentities(entries(map), reader(map));
 	const keys = Object.keys(errors[0] ?? {}).sort();
 	assert.deepStrictEqual(keys, ["filename", "message"], `error keyset drift: ${keys.join(",")}`);
 	ok("error verbatim-or-nothing (filename + message only, no identity field)", true);
@@ -117,20 +138,81 @@ function reader(map: Record<string, string>): (filename: string) => string {
 	const map = { [`${GID_A}.meta.json`]: rec(GID_A), [`${GID_B}.meta.json`]: "{ broken" };
 	let threw = false;
 	try {
-		listAllMetaIdentities(Object.keys(map), reader(map), { mode: "strict" });
+		listAllMetaIdentities(entries(map), reader(map), { mode: "strict" });
 	} catch {
 		threw = true;
 	}
 	ok("mode strict → throw if any record unreadable", threw);
-	const { identities } = listAllMetaIdentities(Object.keys(map), reader(map), { mode: "collect" });
+	const { identities } = listAllMetaIdentities(entries(map), reader(map), { mode: "collect" });
 	ok("mode collect (default) → partial, no throw", identities.length === 1);
 }
 
 // ── errors sorted by filename ───────────────────────────────────────────────
 {
 	const map = { [`${GID_B}.meta.json`]: "{ x", [`${GID_A}.meta.json`]: "{ y" };
-	const { errors } = listAllMetaIdentities(Object.keys(map), reader(map));
+	const { errors } = listAllMetaIdentities(entries(map), reader(map));
 	ok("errors sorted by filename", errors[0]?.filename === `${GID_A}.meta.json`);
 }
 
+// ── #52: duplicate nativeSessionId is not two citizens ──────────────────────
+{
+	const shared = "n-shared-conversation";
+	const map = {
+		[`${GID_A}.meta.json`]: rec(GID_A, { nativeSessionId: shared }),
+		[`${GID_B}.meta.json`]: rec(GID_B, { nativeSessionId: shared }),
+	};
+	const { identities, errors } = listAllMetaIdentities(entries(map), reader(map));
+	ok("duplicate nativeSessionId → NEITHER record is listed as a citizen", identities.length === 0);
+	ok("duplicate → one error per rival (both are told)", errors.length === 2);
+	ok(
+		"each error names the OTHER holder, so the pair is debuggable from either side",
+		(errors[0]?.message ?? "").includes(`${GID_B}.meta.json`) &&
+			(errors[1]?.message ?? "").includes(`${GID_A}.meta.json`),
+	);
+	ok(
+		"the duplicate error names the fresh-cut verb (one prescription, as everywhere else)",
+		errors.every((e) => e.message.includes("meta-bridge-fresh-cut")),
+	);
+}
+
+// ── #52: a duplicate must not blind the citizens around it ──────────────────
+{
+	const shared = "n-shared-conversation";
+	const GID_C = "20260611T333333-cccccc";
+	const map = {
+		[`${GID_A}.meta.json`]: rec(GID_A, { nativeSessionId: shared }),
+		[`${GID_B}.meta.json`]: rec(GID_B, { nativeSessionId: shared }),
+		[`${GID_C}.meta.json`]: rec(GID_C),
+	};
+	const { identities, errors } = listAllMetaIdentities(entries(map), reader(map));
+	ok(
+		"an unrelated citizen still lists beside a duplicate pair (0.10 lesson holds)",
+		identities.length === 1 && identities[0]?.gardenId === GID_C,
+	);
+	ok("only the two rivals become errors", errors.length === 2);
+}
+
+// ── #52: strict mode refuses a store with a duplicate ───────────────────────
+{
+	const shared = "n-shared-conversation";
+	const map = {
+		[`${GID_A}.meta.json`]: rec(GID_A, { nativeSessionId: shared }),
+		[`${GID_B}.meta.json`]: rec(GID_B, { nativeSessionId: shared }),
+	};
+	let threw = false;
+	try {
+		listAllMetaIdentities(entries(map), reader(map), { mode: "strict" });
+	} catch {
+		threw = true;
+	}
+	ok("mode strict → a duplicate throws like any other unreadable store", threw);
+}
+
+// ── #52: one holder is not a duplicate (no false positive) ──────────────────
+{
+	const map = { [`${GID_A}.meta.json`]: rec(GID_A), [`${GID_B}.meta.json`]: rec(GID_B) };
+	const { identities, errors } = listAllMetaIdentities(entries(map), reader(map));
+	ok("distinct nativeSessionIds are untouched by the uniqueness pass", identities.length === 2 && errors.length === 0);
+}
+
 console.log(`\n[check-meta-listing] ${passed} assertions ok`);

package/scripts/check-meta-receiver-marker.ts

@@ -107,6 +107,60 @@ ok(
 	readMetaReceiverMarker({ gardenId: ghostGarden, receiversDir: DIR, verifyOwner: false }) !== null,
 );
 
+// ── the owner CLAIM, one layer above liveness (#53 A) ───────────────────────
+// A marker naming pid 1 passes the pid-reuse guard on a running Linux host: init is
+// still the very process the marker named, so its start-key matches. The claim is
+// what is false — init owns no Claude session. Such a marker is legacy or corrupt
+// residue (any pre-fix writer that was reparented to init; a foreign/damaged file);
+// the one observed was a shell-form hook. Honoring it made a dead garden id read as
+// an ACTIVE RECEIVER and, one surface over, left meta-bridge-fresh-cut unable to be
+// unblocked by the action it prescribes (#53 A).
+const initGarden = "20260614T130000-cccccc";
+const initKey = processStartKey(1);
+ok("this host CAN read a start key for pid 1 (the residue cells are not vacuous)", initKey !== "");
+writeFileSync(
+	metaReceiverMarkerPath(initGarden, DIR),
+	`${JSON.stringify({
+		gardenId: initGarden,
+		backend: "claude-code",
+		nativeSessionId: "n-init",
+		ownerPid: 1,
+		ownerStartKey: initKey, // the REAL key: the pid-reuse guard would pass
+		ownerKind: "claude-code-cli",
+		armProvenance: "session-start",
+		updatedAt: "2026-06-10T16:03:10.000Z",
+	})}\n`,
+);
+ok(
+	"an init-owned marker reads as null — pid 1 cannot own a session, however live init is",
+	readMetaReceiverMarker({ gardenId: initGarden, receiversDir: DIR }) === null,
+);
+ok(
+	"the classifier itself still says LIVE for it — the refusal is a CLAIM rule, not a liveness one",
+	classifyMarkerOwner(initKey, { currentStartKey: processStartKey(1), pidExists: probePidExistence(1) }) === "live",
+);
+ok(
+	"verifyOwner:false does NOT reach past plausibility (it opts out of liveness, not of validity)",
+	readMetaReceiverMarker({ gardenId: initGarden, receiversDir: DIR, verifyOwner: false }) === null,
+);
+let initWriteRejected = false;
+try {
+	writeMetaReceiverMarker({
+		gardenId: initGarden,
+		backend: "claude-code",
+		nativeSessionId: "n-init",
+		ownerPid: 1,
+		armProvenance: "session-start",
+		receiversDir: DIR,
+	});
+} catch {
+	initWriteRejected = true;
+}
+ok(
+	"minting an init-owned receiver marker THROWS at the write boundary (no writer can reintroduce it)",
+	initWriteRejected,
+);
+
 // ── armProvenance constraint ────────────────────────────────────────────────
 ok(
 	"arm provenances are exactly the arm-capable events",

package/scripts/check-model-lock.ts

@@ -211,7 +211,7 @@ async function makeHarness(opts: MakeHarnessOpts = {}): Promise<Harness> {
 const NATIVE_A: ModelLike = { provider: "openai-codex", id: "gpt-5.4" };
 const NATIVE_B: ModelLike = { provider: "openai-codex", id: "gpt-5.5" };
 const PSA_SONNET: ModelLike = { provider: "entwurf", id: "claude-sonnet-5" };
-const PSA_OPUS: ModelLike = { provider: "entwurf", id: "claude-opus-4-8" };
+const PSA_OPUS: ModelLike = { provider: "entwurf", id: "claude-opus-5" };
 
 let passed = 0;
 let failed = 0;

package/scripts/check-shell-quote.ts

@@ -6,7 +6,8 @@
  * Backticks and `$(...)` inside a user prompt got executed by the remote shell
  * before pi ever saw them. The fix introduced `shellQuote()` (POSIX `'...'`
  * with `'\''` escape) in two places:
- *   - pi-extensions/lib/entwurf-core.ts (legacy sync spawn/resume helper while v2 extraction is in progress)
+ *   - pi-extensions/lib/entwurf-core.ts (the one remaining site; the entwurf.ts /
+ *     entwurf-async.ts siblings this once cross-checked were removed in 0.12)
  *
  * This script enforces two invariants:
  *   1. `shellQuote()` source matches the reference implementation byte-for-byte.