@junghanacs/entwurf 0.12.0

package/scripts/check-meta-record-v2.ts

@@ -0,0 +1,191 @@
+/**
+ * check-meta-record-v2 — deterministic golden gate for 0.11 Stage 0 step 3A:
+ * the v1→v2 identity normalize seam. Pure functions; no fs, no backend, no API.
+ * Safe in the `pnpm check` static floor.
+ *
+ * THE golden: a synthetic, SANITIZED v1 fixture (no real cwd/transcriptPath —
+ * never commit a real disk meta-record to a public repo) normalizes to a
+ * hand-written v2 identity literal. The golden is a literal, NOT derived from
+ * the same mapping under test, so a drift in `normalizeMetaIdentity` fails here.
+ *
+ * This gate is kept SEPARATE from check-meta-session (the v1 record-authority
+ * gate) on purpose (NEXT.md "dual-read 경로엔 v1 fixture 게이트를 별도 유지"):
+ * when step 3D rewrites the v1 mint/write gates, this v1→v2 compat golden must
+ * survive untouched as the back-compat proof for the 10+ disk v1 records.
+ *
+ * Scope is 3A ONLY: readers (parseMetaRecordV1/V2) + normalizer. There is no v2
+ * writer yet by design — do not add serialize/upsert assertions here until the
+ * golden + its GPT review have landed (NEXT.md 끊을 지점 ①).
+ */
+
+import assert from "node:assert/strict";
+import {
+	MetaRecordError,
+	normalizeMetaIdentity,
+	parseMetaRecordV1,
+	parseMetaRecordV2,
+} from "../pi-extensions/lib/meta-session.ts";
+
+let passed = 0;
+function ok(label: string, cond: boolean): void {
+	assert.ok(cond, label);
+	console.log(`  ok    ${label}`);
+	passed++;
+}
+function golden(label: string, actual: unknown, expected: unknown): void {
+	assert.deepStrictEqual(actual, expected, label);
+	console.log(`  ok    ${label}`);
+	passed++;
+}
+function throws(label: string, fn: () => unknown): void {
+	assert.throws(fn, MetaRecordError, label);
+	console.log(`  ok    ${label}`);
+	passed++;
+}
+
+// --- Synthetic, sanitized v1 fixture (golden source) ------------------------
+// gardenId obeys the SSOT grammar YYYYMMDDTHHMMSS-[0-9a-f]{6}. Paths are
+// synthetic. delivery carries non-null receipts to prove they are DROPPED (not
+// silently carried) by identity normalize.
+const V1_FIXTURE_JSON = JSON.stringify({
+	schemaVersion: 1,
+	gardenId: "20260101T000000-0a1b2c",
+	backend: "claude-code",
+	nativeSessionId: "n-fixture-0001",
+	transcriptPath: "/synthetic/project/.transcript.jsonl",
+	cwd: "/synthetic/project",
+	createdAt: "2026-01-01T00:00:00.000Z",
+	lastSeen: "2026-01-02T03:04:05.000Z",
+	delivery: {
+		wakeMode: "self-fetch",
+		deliveryLevel: "D6",
+		lastEnqueuedAt: null,
+		lastDeliveredAt: "2026-01-02T03:00:00.000Z",
+		lastReadAt: "2026-01-02T03:04:05.000Z",
+	},
+});
+
+// THE golden — hand-written v2 identity (not derived from the mapping).
+const GOLDEN_V2_IDENTITY = {
+	schemaVersion: 2,
+	gardenId: "20260101T000000-0a1b2c",
+	backend: "claude-code",
+	nativeSessionId: "n-fixture-0001",
+	cwd: "/synthetic/project",
+	model: null,
+	transcriptPath: "/synthetic/project/.transcript.jsonl",
+	parentGardenId: null,
+	isEntwurf: false,
+	createdAt: "2026-01-01T00:00:00.000Z",
+	recordUpdatedAt: "2026-01-02T03:04:05.000Z", // = v1 lastSeen (renamed)
+};
+
+// A v2 fixture exercising the deltas: pi backend, null transcriptPath/model,
+// a parent garden id, isEntwurf=true.
+const V2_PI_FIXTURE_JSON = JSON.stringify({
+	schemaVersion: 2,
+	gardenId: "20260301T120000-abc123",
+	backend: "pi",
+	nativeSessionId: "pi-sess-xyz",
+	cwd: "/synthetic/pi-proj",
+	model: null,
+	transcriptPath: null,
+	parentGardenId: "20260301T115900-aaaaaa",
+	isEntwurf: true,
+	createdAt: "2026-03-01T12:00:00.000Z",
+	recordUpdatedAt: "2026-03-01T12:30:00.000Z",
+});
+
+// 1. v1 fixture parses (round-trips to a v1 record carrying delivery).
+const v1 = parseMetaRecordV1(V1_FIXTURE_JSON);
+ok(
+	"parseMetaRecordV1: synthetic v1 fixture parses with delivery intact",
+	v1.schemaVersion === 1 && v1.delivery.lastReadAt === "2026-01-02T03:04:05.000Z",
+);
+
+// 2. THE golden — v1 normalizes to the hand-written v2 identity, byte-for-byte.
+golden(
+	"normalizeMetaIdentity(v1) === golden v2 identity (lastSeen→recordUpdatedAt, delivery dropped)",
+	normalizeMetaIdentity(v1),
+	GOLDEN_V2_IDENTITY,
+);
+
+// 3. v1 identity is LOSSLESS: every identity field survives; only delivery is
+//    intentionally absent (proven by the golden having no delivery key).
+const norm = normalizeMetaIdentity(v1);
+ok(
+	"v1 identity lossless: gardenId/backend/nativeSessionId/cwd/createdAt preserved, transcriptPath carried",
+	norm.gardenId === v1.gardenId &&
+		norm.backend === v1.backend &&
+		norm.nativeSessionId === v1.nativeSessionId &&
+		norm.cwd === v1.cwd &&
+		norm.createdAt === v1.createdAt &&
+		norm.transcriptPath === v1.transcriptPath,
+);
+ok(
+	"v1 recordUpdatedAt is the renamed lastSeen (not createdAt)",
+	norm.recordUpdatedAt === v1.lastSeen && norm.recordUpdatedAt !== norm.createdAt,
+);
+ok("normalized identity carries no delivery aspect", !("delivery" in norm) && !("lastSeen" in norm));
+ok(
+	"new v2 identity fields default at v1→v2 birth",
+	norm.model === null && norm.parentGardenId === null && norm.isEntwurf === false,
+);
+
+// 4. normalize is idempotent: normalize(normalize(v1)) === normalize(v1).
+golden("normalize is idempotent (normalize∘normalize == normalize)", normalizeMetaIdentity(norm), norm);
+
+// 5. v2 fixture parses (the +=pi, nullable transcriptPath/model, parentGardenId,
+//    isEntwurf deltas all accepted).
+const v2 = parseMetaRecordV2(V2_PI_FIXTURE_JSON);
+ok(
+	"parseMetaRecordV2: pi backend + null transcriptPath/model + parent + isEntwurf parses",
+	v2.backend === "pi" &&
+		v2.transcriptPath === null &&
+		v2.model === null &&
+		v2.parentGardenId === "20260301T115900-aaaaaa" &&
+		v2.isEntwurf === true,
+);
+
+// 6. normalize on an already-v2 record is identity (fresh copy, same values).
+golden("normalizeMetaIdentity(v2) === v2 (already identity, returned as stable copy)", normalizeMetaIdentity(v2), v2);
+
+// 7. version fences hold both ways — neither parser accepts the other's version.
+throws("parseMetaRecordV1 rejects a schemaVersion-2 body", () => parseMetaRecordV1(V2_PI_FIXTURE_JSON));
+throws("parseMetaRecordV2 rejects a schemaVersion-1 body", () => parseMetaRecordV2(V1_FIXTURE_JSON));
+
+// 8. v2 validation crashes (not warns) on the new-field contracts.
+throws("parseMetaRecordV2 rejects non-boolean isEntwurf", () =>
+	parseMetaRecordV2(JSON.stringify({ ...JSON.parse(V2_PI_FIXTURE_JSON), isEntwurf: "yes" })),
+);
+throws("parseMetaRecordV2 rejects an unknown backend", () =>
+	parseMetaRecordV2(JSON.stringify({ ...JSON.parse(V2_PI_FIXTURE_JSON), backend: "gemini" })),
+);
+throws("parseMetaRecordV2 rejects a malformed parentGardenId (non-null, bad grammar)", () =>
+	parseMetaRecordV2(JSON.stringify({ ...JSON.parse(V2_PI_FIXTURE_JSON), parentGardenId: "not-a-garden-id" })),
+);
+
+// 9. strict keyset — a v2 body carrying stale v1 fields is half-migrated/corrupt
+//    and must fail-fast, NOT be silently normalized away (GPT review blocker).
+throws("parseMetaRecordV2 rejects a stale v1 `delivery` field", () =>
+	parseMetaRecordV2(
+		JSON.stringify({
+			...JSON.parse(V2_PI_FIXTURE_JSON),
+			delivery: {
+				wakeMode: "self-fetch",
+				deliveryLevel: "D6",
+				lastEnqueuedAt: null,
+				lastDeliveredAt: null,
+				lastReadAt: null,
+			},
+		}),
+	),
+);
+throws("parseMetaRecordV2 rejects a stale v1 `lastSeen` field", () =>
+	parseMetaRecordV2(JSON.stringify({ ...JSON.parse(V2_PI_FIXTURE_JSON), lastSeen: "2026-03-01T12:30:00.000Z" })),
+);
+throws("parseMetaRecordV2 rejects an unknown/extra field", () =>
+	parseMetaRecordV2(JSON.stringify({ ...JSON.parse(V2_PI_FIXTURE_JSON), tmuxTarget: "psa:3.1" })),
+);
+
+console.log(`[check-meta-record-v2] ${passed} assertions ok`);