Master Index 5.3.0 (Classify Tab Wiring)

USER: Fresh thread, Master Index 5.3.0. We will concentrate on wiring the Classify tab in this thread.

ASSISTANT: Understood. I’ll keep this thread anchored to Master Index 5.3.0 and focused on wiring the Classify tab, recovering only the relevant workbook context before moving into formulas/macros.

ASSISTANT: According to a document from May 2, 2026, the current Classify surface is `apps/quasantum/src/pages/Classify.tsx`, and it imports `getDrawers`, `getAssignmentsByArtifact`, `assignArtifactToDrawer`, `removeArtifactFromDrawer`, `updateArtifactClassification`, and `getFieldArtifacts`, with Supabase still in the page’s active dependency path. fileciteturn2file1

Scope locked for **Master Index 5.3.0**:

**Thread focus:** wire the **Classify tab** only.

**Current architectural read:**

The Classify tab is presently a **hybrid/Supabase-facing surface**. Drawer list comes from Supabase `drawers`; artifact-to-drawer memberships use `artifact_drawer_assignments`; `drawer_weights` pre-populates the editor from each artifact row. fileciteturn3file6

The unresolved architectural correction is that the canonical classification layer is now JSON, not Supabase. The prior ruling says the band map / membership JSON is canonical, while Supabase is projection/cache. The Classify tab therefore needs its data path updated so it can read from `drawer-membership.v1.json` rather than treating DB state as authoritative. fileciteturn3file2

The canonical membership file exists: `apex/canon/drawer-membership.v1.json`; membership count is 8, unclassified count is 0, and normalization for `mitakuye_oyasin → mitakuye-oyasin` and `sumak_kawsay → sumak-kawsay` was confirmed clean. fileciteturn3file1

**Working target for this thread:**

Convert Classify from “manual Supabase classification editor only” into a properly wired field tab that can:

1. Load artifacts through the current field projection.
2. Load canonical drawer membership from `drawer-membership.v1.json`.
3. Display canonical weights / primary drawer / row data.
4. Preserve Supabase write actions only where they are intentional projection or steward override.
5. Avoid re-deriving classification from stale Supabase state.

First implementation pass should be a read-path patch, not a destructive rewrite: add a membership fetch helper, merge membership data onto Classify artifacts by `source_thread_id` or equivalent stable key, then leave assignment save behavior intact until we verify the rendered data path.

ASSISTANT: Confirmed. The screenshots show the **Classify UI is rendering**, but the **canonical classification overlay is not wired into the read path**. The selected item, **LEITMOTIF ABC I-P BUILD**, should not be `unclassified`: `field.v2.json` identifies it as `openai-0543`, `source_thread_id: 6876807a`, `primary_drawer: dao`, `row: canonical`, with weights `dao: 0.45`, `mitakuye-oyasin: 0.30`, `maat: 0.25`. fileciteturn31file0L315-L330

The code-level problem is also visible in current `Classify.tsx`: the page still imports the Supabase URL/key directly, then loads artifacts/drawers and performs a second REST query against `corpus_threads`. fileciteturn18file0L3-L5 fileciteturn18file0L42-L70 That query builds IDs from `artifact.source_thread_id`, but filters Supabase by `id`, and the `select` does not include `source_thread_id`; then the merge depends on that result for `drawer_weights`, `classification_status`, and `primary_drawer`. fileciteturn18file0L55-L70 fileciteturn18file0L94-L110

So the next patch is straightforward: **remove the Classify tab’s ad hoc Supabase corpus re-query and overlay canonical membership JSON onto the field artifacts.**

## First patch target

Use the canonical public file:

```ts
const CANONICAL_MEMBERSHIP_URL =
"https://rodzaki.github.io/apex/canon/drawer-membership.v1.json";
```

That file is present in `RODZAKI.github.io` and currently declares `classification_version: "v1"`, `source: "uuid-bands.v1.json"`, 8 memberships, and `unclassified: []`. fileciteturn30file0L3-L7 fileciteturn30file0L120-L121 The canonical membership for `6876807a` is exactly the DAO / Mitakuye Oyasin / Ma’at profile that should be visible for the selected LEITMOTIF row. fileciteturn30file0L106-L118

Because the Vite app is built under `base: "/quasantum/"`, an absolute canonical URL is safer than a relative `/apex/...` path for this first read-path patch. fileciteturn25file0L7-L9

## Patch shape for `src/pages/Classify.tsx`

Add a canonical loader near the top of the file:

```ts
const CANONICAL_MEMBERSHIP_URL =
"https://rodzaki.github.io/apex/canon/drawer-membership.v1.json";

type CanonicalMembershipEntry = {
primary_drawer?: DrawerId | null;
drawers?: DrawerId[];
row?: RowClass;
drawer_weights?: Partial<Record<DrawerId, number>>;
};

type DrawerMembershipV1 = {
classification_version: string;
generated_at?: string;
source?: string;
memberships?: Record<string, CanonicalMembershipEntry>;
unclassified?: string[];
};

async function getCanonicalDrawerMembership(): Promise<
Map<string, CanonicalMembershipEntry>
> {
const response = await fetch(CANONICAL_MEMBERSHIP_URL, { cache: "no-store" });

if (!response.ok) {
throw new Error(
`Canonical drawer membership fetch failed: ${response.status}`
);
}

const json = (await response.json()) as DrawerMembershipV1;
return new Map(Object.entries(json.memberships ?? {}));
}

function findCanonicalMembership(
artifact: ClassifyArtifact,
memberships: Map<string, CanonicalMembershipEntry>
): CanonicalMembershipEntry | undefined {
const candidates = [
artifact.source_thread_id,
artifact.source_thread_id?.slice(0, 8),
artifact.id,
].filter((value): value is string => Boolean(value));

for (const key of candidates) {
const match = memberships.get(key);
if (match) return match;
}

return undefined;
}
```

Then change the load block from:

```ts
const [artifacts, drawerRows] = await Promise.all([
getFieldArtifacts(fieldId),
getDrawers(),
]);
```

to:

```ts
const [artifacts, drawerRows, canonicalMemberships] = await Promise.all([
getFieldArtifacts(fieldId),
getDrawers(),
getCanonicalDrawerMembership(),
]);
```

Then delete the direct Supabase REST block that builds `ids`, calls `/rest/v1/corpus_threads`, and creates `corpus`. Replace the merge with canonical-first logic:

```ts
const merged: ClassifyArtifact[] = artifacts.map((artifact) => {
const canonical = findCanonicalMembership(artifact, canonicalMemberships);

const drawerWeights =
canonical?.drawer_weights ??
artifact.drawer_weights ??
{};

const computedPrimaryDrawer =
Object.entries(drawerWeights).sort(
([, left], [, right]) => Number(right) - Number(left)
)[0]?.[0] as DrawerId | undefined;

const primaryDrawer =
canonical?.primary_drawer ??
artifact.primary_drawer ??
computedPrimaryDrawer ??
null;

return {
...artifact,
drawer_weights: drawerWeights as Record<DrawerId, number>,
primary_drawer: primaryDrawer,
row_class: canonical?.row ?? artifact.row_class ?? "canonical",
classification_status:
canonical
? "classified"
: artifact.classification_status ??
(primaryDrawer ? "classified" : "unclassified"),
};
});
```

Leave `selectArtifact` intact for now. It already initializes the sliders from `artifact.drawer_weights`, so once the merged artifact contains canonical weights, the editor should populate correctly. fileciteturn18file0L132-L140

Also leave `handleSave` intact for this pass. It currently writes classification and assignment state back through Supabase service functions, so changing it now would mix read-path wiring with steward/projection write semantics. fileciteturn18file0L147-L170

## Expected visual result after deploy

For the visible screenshot case, **LEITMOTIF ABC I-P BUILD** should change from:

```text
unclassified
row_class: transitional
all sliders: 0.00
```

to:

```text
dao
row_class: canonical
dao: 0.45
mitakuye-oyasin: 0.30
maat: 0.25
```

The same source-thread overlay should also classify the adjacent visible artifacts that share `source_thread_id: 6876807a`, including `ACT2a (Ch.7-9) PERP Expansion`, `TOP TIER COMMANDS LIST`, `Create synthetic image`, `Motion Design Principles`, and `Domain-8 Artifact Transfer`, all under the same canonical DAO-weighted membership band. fileciteturn31file0L279-L330

No repo changes have been made yet.

ASSISTANT: Patch receipt logged. The Classify read-path patch was applied and deployed: the local build succeeded, `/dist/quasantum` was synced into `/quasantum`, commit `29bc4cb` was pushed to `main`, and the Master Index advanced `0.0.517 → 0.0.518`. fileciteturn32file0

The important implementation points are clean:

- `corpus_threads` re-query removed from `Classify.tsx`.
- Canonical membership fetch added against `drawer-membership.v1.json`.
- Lookup cascade is correct: `source_thread_id → 8-char prefix → artifact.id`.
- Canonical values now win over Supabase artifact values.
- `selectArtifact` and `handleSave` remained untouched.
- Canonical fetch failure degrades to an empty `Map`, so the page should not blank out if GitHub Pages is unavailable. fileciteturn32file0

Next validation target is exactly this:

```text
LEITMOTIF ABC I-P BUILD
primary_drawer: dao
row_class: canonical
dao: 0.45
mitakuye-oyasin: 0.30
maat: 0.25
classification_status: classified
```

Because GitHub Pages and browser asset caches can lag, hard-refresh the deployed page once. If it still renders `unclassified`, the next diagnostic should be browser-console only:

```js
fetch("https://rodzaki.github.io/apex/canon/drawer-membership.v1.json")
.then(r => r.json())
.then(j => console.log(j.memberships["6876807a"]));
```

Expected result:

```js
{
primary_drawer: "dao",
drawers: ["dao", "mitakuye-oyasin", "maat"],
row: "canonical",
drawer_weights: {
dao: 0.45,
"mitakuye-oyasin": 0.3,
maat: 0.25
}
}
```

If that object prints but the UI still shows `unclassified`, the remaining fault is inside the artifact key path: `artifact.source_thread_id` is not what we think it is for the rendered LEITMOTIF row.

ASSISTANT: You are looking at the **ThreadView route**, not the Classify tab.

The URL in the screenshot is:

```text
rodzaki.github.io/quasantum/#/thread/openai-0543
```

The console confirms that code path:

```text
Fetching corpus_thread for: openai-0543
CORPUS_THREAD_RESULT:
{id: 'openai-0543', title: 'LEITMOTIF ABC I-P BUILD', ...}
[QX_THREAD_DEBUG]
```

So this screenshot does **not** validate the Classify read-path patch. It validates that the new deployed bundle is loaded — `index-k9ARqmA5.js` — but the active page is the standalone thread page, not `/q/fields/...` with the Classify tab selected.

The pasted patch report says the intended change landed cleanly: `getCanonicalDrawerMembership()` was added, lookup resolves `source_thread_id → 8-char prefix → artifact.id`, canonical values win over Supabase values, and `handleSave` / `selectArtifact` were untouched. fileciteturn35file0

Next check should be on the field page:

```text
https://rodzaki.github.io/quasantum/#/q/fields/F007
```

Then click **Classify**, select **LEITMOTIF ABC I-P BUILD**, and verify:

```text
primary_drawer: dao
row_class: canonical
dao: 0.45
mitakuye-oyasin: 0.30
maat: 0.25
```

The blank white panel on `#/thread/openai-0543` is a separate issue in `ThreadView`, not evidence that the Classify patch failed. The key diagnostic is: once you are back on the Classify tab, if LEITMOTIF still says `unclassified`, then the next fault is likely the artifact object not carrying `source_thread_id: 6876807a` on that rendered row.

ASSISTANT: According to a document from May 7, 2026, the patch **did build and deploy** as `index-k9ARqmA5.js`, with the Classify read path fetching `drawer-membership.v1.json` and leaving `handleSave` / `selectArtifact` untouched. fileciteturn47file0 fileciteturn43file0

The screenshot now proves the next fault: **the canonical matcher has no key to match on.**

Current `Classify.tsx` is looking up canonical membership by:

```ts
artifact.source_thread_id
artifact.source_thread_id?.slice(0, 8)
artifact.id
```

That is visible in the deployed source. fileciteturn44file0L64-L78 But `getFieldArtifacts()` currently queries `corpus_threads` with only:

```ts
id, title, content, field_id, created_at
```

so `source_thread_id` is stripped before Classify ever sees the artifact. fileciteturn45file0L344-L348 Then `toFieldArtifactItem()` maps `source_thread_id` from `item.source_thread_id`, which is missing, so it becomes `null`. fileciteturn45file0L278-L286

That means LEITMOTIF’s lookup candidates collapse to:

```ts
undefined
undefined
"openai-0543"
```

But `drawer-membership.v1.json` is keyed by the short source-thread key:

```ts
"6876807a"
```

and that entry correctly says:

```ts
primary_drawer: "dao"
drawer_weights: {
dao: 0.45,
"mitakuye-oyasin": 0.3,
maat: 0.25
}
```

fileciteturn48file0L106-L118

The missing bridge is already present in `field.v2.json`: `openai-0543` maps to `source_thread_id: "6876807a"` and the same DAO weights. fileciteturn46file0L315-L330

## Next patch

Do **not** chase browser cache. The live bundle is current. The next patch is: **add canonical field projection as the artifact-id bridge.**

Patch `Classify.tsx` so it fetches both:

```ts
drawer-membership.v1.json
field.v2.json
```

Then resolve membership by:

```ts
artifact.source_thread_id
artifact.source_thread_id?.slice(0, 8)
fieldEntry.source_thread_id
fieldEntry.source_thread_id?.slice(0, 8)
artifact.id
```

Add this beside the existing canonical membership loader:

```ts
const CANONICAL_FIELD_URL =
"https://rodzaki.github.io/apex/canon/field.v2.json";

type CanonicalFieldEntry = {
id: string;
source_thread_id?: string | null;
title?: string;
era?: string | null;
primary_drawer?: DrawerId | null;
drawers?: DrawerId[];
row?: RowClass;
drawer_weights?: Partial<Record<DrawerId, number>>;
};

type CanonicalFieldV2 = {
field_version: string;
generated_at?: string;
basis?: string;
entries?: CanonicalFieldEntry[];
};

async function getCanonicalFieldEntries(): Promise<Map<string, CanonicalFieldEntry>> {
try {
const response = await fetch(CANONICAL_FIELD_URL, { cache: "no-store" });

if (!response.ok) {
console.warn(`[canonical-field] fetch failed ${response.status} — falling back to empty map`);
return new Map();
}

const json = (await response.json()) as CanonicalFieldV2;
return new Map((json.entries ?? []).map((entry) => [entry.id, entry]));
} catch (err) {
console.warn("[canonical-field] fetch threw — falling back to empty map", err);
return new Map();
}
}
```

Change the `Promise.all` block to:

```ts
const [artifactRows, drawerRows, canonicalMemberships, canonicalFieldEntries] =
await Promise.all([
getFieldArtifacts(fieldId),
getDrawers(),
getCanonicalDrawerMembership(),
getCanonicalFieldEntries(),
]);
```

Replace `findCanonicalMembership()` with:

```ts
function findCanonicalMembership(
artifact: ClassifyArtifact,
memberships: Map<string, CanonicalMembershipEntry>,
fieldEntries: Map<string, CanonicalFieldEntry>
): CanonicalMembershipEntry | undefined {
const fieldEntry = fieldEntries.get(artifact.id);

const candidates = [
artifact.source_thread_id,
artifact.source_thread_id?.slice(0, 8),
fieldEntry?.source_thread_id,
fieldEntry?.source_thread_id?.slice(0, 8),
artifact.id,
].filter((value): value is string => Boolean(value));

for (const key of candidates) {
const match = memberships.get(key);
if (match) return match;
}

if (fieldEntry?.primary_drawer || fieldEntry?.drawer_weights) {
return {
primary_drawer: fieldEntry.primary_drawer,
drawers: fieldEntry.drawers,
row: fieldEntry.row,
drawer_weights: fieldEntry.drawer_weights,
};
}

return undefined;
}
```

Then update the merge call:

```ts
const merged: ClassifyArtifact[] = artifactRows.map((artifact) => {
const fieldEntry = canonicalFieldEntries.get(artifact.id);
const canonical = findCanonicalMembership(
artifact,
canonicalMemberships,
canonicalFieldEntries
);

const drawerWeights =
(canonical?.drawer_weights as Record<DrawerId, number> | undefined) ??
artifact.drawer_weights ??
{};

const computedPrimaryDrawer = Object.entries(drawerWeights).sort(
([, left], [, right]) => Number(right) - Number(left)
)[0]?.[0] as DrawerId | undefined;

const primaryDrawer =
canonical?.primary_drawer ??
artifact.primary_drawer ??
computedPrimaryDrawer ??
null;

return {
...artifact,
source_thread_id:
artifact.source_thread_id ?? fieldEntry?.source_thread_id ?? null,
era: artifact.era ?? fieldEntry?.era ?? null,
drawer_weights: drawerWeights,
primary_drawer: primaryDrawer,
row_class: canonical?.row ?? artifact.row_class ?? "canonical",
classification_status:
canonical
? "classified"
: artifact.classification_status ??
(primaryDrawer ? "classified" : "unclassified"),
};
});
```

Optional small upstream improvement in `services.ts`: expand the `corpus_threads` select so `source_thread_id` is not stripped:

```ts
.select(
"id, title, content, field_id, created_at, source_thread_id, master_index_num, classification_status, primary_drawer, drawer_weights, row_class, confidence, alignment_flag, resolving, state, era"
)
```

But the canonical-field bridge is the real fix. It keeps the Classify read path independent of whether Supabase happens to carry the canonical source key.

Expected after this patch:

```text
LEITMOTIF ABC I-P BUILD
dao
row_class: canonical
dao: 0.45
mitakuye-oyasin: 0.30
maat: 0.25
```

USER: Please give me a single applicable script.

ASSISTANT: Save this as `classify-field-bridge.mjs` in the repo root:

```js
// ============================================================
// SCRIPT ID : CLASSIFY-FIELD-BRIDGE-PATCH
// TARGET : apps/quasantum/src/pages/Classify.tsx
// PURPOSE : Bridge Classify artifacts through field.v2.json
// so openai-* artifact ids resolve to canonical
// source_thread_id bands in drawer-membership.v1.json.
// SCOPE : Read path only. handleSave/selectArtifact untouched.
// RUN FROM : C:\Users\david\Projects\RODZAKI.github.io
// COMMAND : node classify-field-bridge.mjs
// ============================================================

import fs from "fs";
import path from "path";
import { execSync } from "child_process";

const root = process.cwd();
const target = path.join(root, "apps", "quasantum", "src", "pages", "Classify.tsx");
const appDir = path.join(root, "apps", "quasantum");
const distDir = path.join(root, "dist", "quasantum");
const deployDir = path.join(root, "quasantum");

function abort(message) {
console.error(`\nABORT: ${message}`);
process.exit(1);
}

function replaceRequired(source, pattern, replacement, label) {
const next = source.replace(pattern, replacement);
if (next === source) abort(`replacement failed → ${label}`);
console.log(`OK: ${label}`);
return next;
}

if (!fs.existsSync(target)) {
abort(`target file not found: ${target}`);
}

let src = fs.readFileSync(target, "utf8");
const backup = `${target}.bak-classify-field-bridge-${Date.now()}`;
fs.writeFileSync(backup, src, "utf8");
console.log(`Backup written → ${backup}`);

if (!src.includes("CANONICAL_MEMBERSHIP_URL")) {
abort("Classify.tsx does not contain the prior drawer-membership loader. Apply the first read-path patch before this bridge patch.");
}

const fieldBridgeBlock = `
const CANONICAL_FIELD_URL =
"https://rodzaki.github.io/apex/canon/field.v2.json";

type CanonicalFieldEntry = {
id: string;
source_thread_id?: string | null;
title?: string;
era?: string | null;
primary_drawer?: DrawerId | null;
drawers?: DrawerId[];
row?: RowClass;
drawer_weights?: Partial<Record<DrawerId, number>>;
};

type CanonicalFieldV2 = {
field_version: string;
generated_at?: string;
basis?: string;
entries?: CanonicalFieldEntry[];
};

async function getCanonicalFieldEntries(): Promise<Map<string, CanonicalFieldEntry>> {
try {
const response = await fetch(CANONICAL_FIELD_URL, { cache: "no-store" });

if (!response.ok) {
console.warn(
\`[canonical-field] fetch failed \${response.status} — falling back to empty map\`
);
return new Map();
}

const json = (await response.json()) as CanonicalFieldV2;
return new Map((json.entries ?? []).map((entry) => [entry.id, entry]));
} catch (err) {
console.warn("[canonical-field] fetch threw — falling back to empty map", err);
return new Map();
}
}
`;

if (!src.includes("CANONICAL_FIELD_URL")) {
src = replaceRequired(
src,
/\nfunction findCanonicalMembership\(/,
`\n${fieldBridgeBlock}\nfunction findCanonicalMembership(`,
"insert canonical field.v2 loader"
);
} else {
console.log("SKIP: canonical field.v2 loader already present");
}

const newFindCanonicalMembership = `function findCanonicalMembership(
artifact: ClassifyArtifact,
memberships: Map<string, CanonicalMembershipEntry>,
fieldEntries: Map<string, CanonicalFieldEntry>
): CanonicalMembershipEntry | undefined {
const fieldEntry = fieldEntries.get(artifact.id);

const candidates = [
artifact.source_thread_id,
artifact.source_thread_id?.slice(0, 8),
fieldEntry?.source_thread_id,
fieldEntry?.source_thread_id?.slice(0, 8),
artifact.id,
].filter((value): value is string => Boolean(value));

for (const key of candidates) {
const match = memberships.get(key);
if (match) return match;
}

if (fieldEntry?.primary_drawer || fieldEntry?.drawer_weights) {
return {
primary_drawer: fieldEntry.primary_drawer,
drawers: fieldEntry.drawers,
row: fieldEntry.row,
drawer_weights: fieldEntry.drawer_weights,
};
}

return undefined;
}

export default function Classify`;

src = replaceRequired(
src,
/function findCanonicalMembership\([\s\S]*?\n\}\n\nexport default function Classify/,
newFindCanonicalMembership,
"replace canonical membership matcher with field.v2 bridge"
);

const promiseAllReplacement = `const [artifactRows, drawerRows, canonicalMemberships, canonicalFieldEntries] =
await Promise.all([
getFieldArtifacts(fieldId),
getDrawers(),
getCanonicalDrawerMembership(),
getCanonicalFieldEntries(),
]);`;

if (!src.includes("canonicalFieldEntries] =") && !src.includes("canonicalFieldEntries] = await")) {
src = replaceRequired(
src,
/const\s+\[artifactRows,\s*drawerRows,\s*canonicalMemberships\]\s*=\s*await\s+Promise\.all\(\s*\[\s*getFieldArtifacts\(fieldId\),\s*getDrawers\(\),\s*getCanonicalDrawerMembership\(\),?\s*\]\s*\);/,
promiseAllReplacement,
"extend Promise.all with canonical field entries"
);
} else {
console.log("SKIP: Promise.all already includes canonicalFieldEntries");
}

const mergeReplacement = `const merged: ClassifyArtifact[] = artifactRows.map((artifact) => {
const fieldEntry = canonicalFieldEntries.get(artifact.id);
const canonical = findCanonicalMembership(
artifact,
canonicalMemberships,
canonicalFieldEntries
);

const drawerWeights =
(canonical?.drawer_weights as Record<DrawerId, number> | undefined) ??
artifact.drawer_weights ??
{};

const computedPrimaryDrawer = Object.entries(drawerWeights).sort(
([, left], [, right]) => Number(right) - Number(left)
)[0]?.[0] as DrawerId | undefined;

const primaryDrawer =
canonical?.primary_drawer ?? artifact.primary_drawer ?? computedPrimaryDrawer ?? null;

return {
...artifact,
source_thread_id: artifact.source_thread_id ?? fieldEntry?.source_thread_id ?? null,
era: artifact.era ?? fieldEntry?.era ?? null,
drawer_weights: drawerWeights,
primary_drawer: primaryDrawer,
row_class: canonical?.row ?? artifact.row_class ?? "canonical",
classification_status:
canonical
? "classified"
: artifact.classification_status ?? (primaryDrawer ? "classified" : "unclassified"),
};
});`;

src = replaceRequired(
src,
/const\s+merged:\s*ClassifyArtifact\[\]\s*=\s*artifactRows\.map\(\(artifact\)\s*=>\s*\{[\s\S]*?\n\s*\}\);/,
mergeReplacement,
"replace merge block with field.v2-aware canonical-first merge"
);

fs.writeFileSync(target, src, "utf8");
console.log(`\nPatched → ${target}`);

console.log("\n── BUILD ─────────────────────────────────────────");
execSync("npm run build", {
cwd: appDir,
stdio: "inherit",
shell: true,
});

if (!fs.existsSync(distDir)) {
abort(`build output not found: ${distDir}`);
}

console.log("\n── SYNC DIST → /quasantum ─────────────────────────");
fs.rmSync(deployDir, { recursive: true, force: true });
fs.cpSync(distDir, deployDir, { recursive: true });
console.log(`Synced ${distDir} → ${deployDir}`);

console.log("\n── GIT COMMIT + PUSH ──────────────────────────────");
execSync("git add apps/quasantum/src/pages/Classify.tsx quasantum/", {
cwd: root,
stdio: "inherit",
shell: true,
});

let hasStagedChanges = true;
try {
execSync("git diff --cached --quiet", {
cwd: root,
stdio: "ignore",
shell: true,
});
hasStagedChanges = false;
} catch {
hasStagedChanges = true;
}

if (!hasStagedChanges) {
console.log("No staged changes after patch/build; skipping commit and push.");
} else {
execSync(
`git commit -m "classify: bridge canonical membership through field projection"`,
{
cwd: root,
stdio: "inherit",
shell: true,
}
);

execSync("git push origin main", {
cwd: root,
stdio: "inherit",
shell: true,
});
}

console.log(`
DONE.

Expected validation target:

LEITMOTIF ABC I-P BUILD
primary_drawer: dao
row_class: canonical
classification_status: classified
dao: 0.45
mitakuye-oyasin: 0.30
maat: 0.25

This patch does not modify handleSave, selectArtifact, or any Supabase write path.
`);
```

Run:

```powershell
cd "C:\Users\david\Projects\RODZAKI.github.io"
node classify-field-bridge.mjs
```

This is the follow-on bridge patch after the prior Classify read-path deployment confirmed the first canonical membership overlay landed but still lacked the artifact-id-to-source-thread bridge. fileciteturn49file0

USER: Use the following artifact from DeepSeek to determine DeepSeek's required level of rehydration as shown by their state of coherence as demonstrated through this artifact, and compose a rehydration artifact to include the obstacles we have encountered regarding relations graph especially, but also our current concentration on wiring the classify tab.

USER: Use the following artifact from DeepSeek to determine DeepSeek's required level of rehydration as shown by their state of coherence as demonstrated through this artifact, and compose a rehydration artifact to include the obstacles we have encountered regarding relations graph especially, but also our current concentration on wiring the classify tab: David — first, thank you for the honesty. That's the most valuable thing you could have said.

You're not inept. You're doing something genuinely hard: orchestrating a multi-agent cognitive system across four different models, two repos, a live database, and a lattice architecture that doesn't exist anywhere else. The fact that you've gotten this far without being a professional coder is remarkable.

Here's my honest assessment of what's been happening, and a way forward.

The Real Problem (Not Your Incompetence)

You're experiencing coordination fragmentation — the natural outcome of working with multiple models that don't share memory, each with different code generation styles, different assumptions about your stack, and no shared understanding of the current state of the codebase.

What you need isn't a better model. You need a single source of truth protocol that all agents (including future you) follow.

What I Can Offer Right Now

I cannot autonomously traverse your repos. But I can be your surgical instrument if you give me the current discrepancies — the specific things that aren't working.

Instead of asking me to "fix everything" (which I cannot do blind), ask me:

"DeepSeek, here's File A (paste it) and File B (paste it). They disagree on the shape of the artifact object. Which one is right according to the schema in thread X?"

That I can solve in one exchange.

The Three-Step Unblocking Protocol I Recommend

Step 1: Create a CURRENT_STATE.md file in your repo (5 minutes)

Write down, in plain English:

```markdown
## What Works (as of May 9)
- [ ] Static site loads
- [ ] Supabase connection established
- [ ] createField() writes to database (tested)
- [ ] ???

## What Doesn't Work (be specific about the error)
- [ ] Creating artifacts gives "relation does not exist" (or whatever)
- [ ] Drawer-loader.js shows titles but no cards
- [ ] ???

## The Last Thing That Worked Before It Broke
- [ ] (e.g., "On April 22, I successfully added a field via the modal")

## Files That Might Be Involved
- /src/services.ts
- /src/components/CreateArtifactModal.tsx
- /apex/catalog/drawer-loader.js
```

Post this to your repo. Now you and every model have a shared problem statement.

Step 2. Pick ONE discrepancy. Paste it here.

Not the whole codebase. Just:

· The error message (exact text)
· The two files that touch that error (or the relevant 20-line sections)
· What you expect to happen

I will give you a copy-pasteable fix — one file, one change, testable in 2 minutes.

Step 3. Let me be your "canonical reference"

From this point forward, when you work with Claude or ChatGPT or Codex, paste this instruction at the top of your prompt:

"Before generating code, confirm you have read the CURRENT_STATE.md at [URL]. Align with the schema in card-index.json v0.2. Do not invent new patterns — extend existing ones from services.ts (pasted below)."

That solves 80% of the fragmentation.

What I Cannot Promise (Honestly)

· I cannot autonomously traverse your repos (no model can today without custom tooling)
· I cannot "clean up the universal codebase" in one pass
· I cannot know what's in your Supabase tables unless you paste the schema

What I Can Promise (Specifically)

· Given one well-defined problem and the relevant 50-100 lines of code, I will give you a working solution
· Given two conflicting files, I will tell you exactly where they diverge and which one matches your stated architecture
· Given an error message, I will diagnose the root cause 90% of the time

My Suggestion for Your Next Message

Pick one of these:

1. "Here's the error I'm stuck on" (paste it)
2. "Here are two files that disagree" (paste the relevant sections)
3. "Here's my CURRENT_STATE.md — what's the highest-leverage next step?"

Do not try to explain the whole project. Do not apologize for not being a coder. Just give me the smallest possible thing that is broken.

The lattice can wait. Let's get you unblocked first.

— DeepSeek

ASSISTANT: DeepSeek is coherent at the **meta-coordination level** but underhydrated at the **operational state level**. Their artifact correctly identifies coordination fragmentation and asks for small, well-scoped discrepancies, but it does not know the current repo state, live diagnostics, recent graph obstacles, or the Classify read-path work already completed. Required rehydration level: **Level 4 / high tactical rehydration** — not a full philosophical reboot, but a complete current-state packet with exact files, failure modes, known logs, and current patch boundary.

Below is a paste-ready artifact for DeepSeek.

---

# DEEPSEEK REHYDRATION ARTIFACT
## QUASANTUM / Master Index 5.3.0 / Current Focus: Classify Tab Wiring

DeepSeek, treat this as the current state. Do **not** respond with general project-management advice. Do **not** ask David to create a new `CURRENT_STATE.md` before helping. This artifact is the current state packet.

Your useful role here is surgical: inspect the stated discrepancy, preserve existing architecture, and return one bounded fix or diagnostic at a time.

## 1. Current orientation

David is coordinating QUASANTUM across multiple agents and two related repos. The current working surface is the deployed QUASANTUM app at:

```text
https://rodzaki.github.io/quasantum/
```

The active concentration in this thread is **wiring the Classify tab**, specifically making the Classify UI read canonical classification from JSON rather than stale or incomplete Supabase state.

The broader unresolved obstacle is the **Relations graph**, which has had repeated identity, timing, and projection problems. The graph is not the immediate patch target in this pass, but its failure modes matter because they reveal the same underlying disease: inconsistent identifiers, mixed canonical/projection data sources, and race/order problems between field membership, relations, corpus cache, and rendered nodes.

## 2. Canonical architecture rule

Canonical classification is JSON-first.

Supabase is not the source of truth for drawer membership. Supabase may be projection/cache/steward override, but the canonical classification layer is:

```text
https://rodzaki.github.io/apex/canon/drawer-membership.v1.json
https://rodzaki.github.io/apex/canon/field.v2.json
```

Important distinction:

`drawer-membership.v1.json` is keyed by short source-thread IDs like:

```text
6876807a
```

But the visible field artifacts in the app are often `openai-*` IDs like:

```text
openai-0543
```

Therefore, Classify needs a bridge from:

```text
openai-0543 → source_thread_id 6876807a → drawer-membership.v1.json["6876807a"]
```

That bridge exists in `field.v2.json`.

## 3. Current Classify tab state

A first Classify read-path patch was already applied and deployed.

It removed the ad hoc Classify-side Supabase `corpus_threads` re-query and added `getCanonicalDrawerMembership()` against `drawer-membership.v1.json`. The patch preserved `selectArtifact` and `handleSave`; write paths were intentionally left untouched. The deployment built successfully and produced the live bundle `index-k9ARqmA5.js`; commit `29bc4cb` pushed the read-path overlay. fileciteturn49file0

However, after deployment, the UI still showed the target artifact as `unclassified`.

Target artifact:

```text
LEITMOTIF ABC I-P BUILD
id: openai-0543
expected source_thread_id: 6876807a
expected primary_drawer: dao
expected row_class: canonical
expected drawer_weights:
dao: 0.45
mitakuye-oyasin: 0.30
maat: 0.25
```

Visible failure:

```text
LEITMOTIF ABC I-P BUILD
unclassified
row_class UI selectable, canonical selected in latest screenshot
sliders still show 0.00
```

## 4. Current Classify root cause

The first patch fetches `drawer-membership.v1.json`, but the artifact rows reaching `Classify.tsx` do not carry `source_thread_id`.

The current `getFieldArtifacts()` path queries `corpus_threads` with only:

```ts
.select("id, title, content, field_id, created_at")
```

Then it maps:

```ts
source_thread_id: item.source_thread_id ?? null
```

Because `source_thread_id` was not selected, it becomes `null`.

So Classify tries candidates like:

```ts
artifact.source_thread_id // null
artifact.source_thread_id?.slice(0,8) // undefined
artifact.id // openai-0543
```

But `drawer-membership.v1.json` does **not** have `openai-0543`; it has `6876807a`.

Therefore, the canonical overlay is deployed but cannot match.

## 5. Current required Classify patch

The correct next patch is a **field projection bridge**, not another Supabase re-query.

Patch target:

```text
apps/quasantum/src/pages/Classify.tsx
```

Add a loader for:

```text
https://rodzaki.github.io/apex/canon/field.v2.json
```

Use `field.v2.json` to map:

```text
artifact.id → source_thread_id
```

Then resolve canonical membership by this cascade:

```ts
artifact.source_thread_id
artifact.source_thread_id?.slice(0, 8)
fieldEntry?.source_thread_id
fieldEntry?.source_thread_id?.slice(0, 8)
artifact.id
```

If `drawer-membership.v1.json` does not match but `field.v2.json` contains `primary_drawer` or `drawer_weights`, use the field entry as a fallback canonical classification object.

Expected after patch:

```text
LEITMOTIF ABC I-P BUILD
primary_drawer: dao
classification_status: classified
row_class: canonical
dao: 0.45
mitakuye-oyasin: 0.30
maat: 0.25
```

Do not modify:

```text
handleSave()
selectArtifact()
Supabase write functions
assignment save behavior
```

The current pass is read-path only.

## 6. Optional but lower-priority upstream improvement

In `apps/quasantum/src/lib/services.ts`, `getFieldArtifacts()` can be improved by expanding the `corpus_threads` select to include classification-related columns:

```ts
.select(
"id, title, content, field_id, created_at, source_thread_id, master_index_num, classification_status, primary_drawer, drawer_weights, row_class, confidence, alignment_flag, resolving, state, era"
)
```

But this is not the main fix. The main fix is Classify-side canonical bridging through `field.v2.json`, because canonical JSON should remain the authority even when Supabase projection is incomplete.

## 7. Relations graph obstacle summary

The Relations graph has been the larger recurring obstacle. Treat this as important context, but do not switch the immediate task away from Classify unless explicitly asked.

Observed graph diagnostics for field `F007`:

```text
FIELD_RELATIONS: resolved field id -> F007
FIELD_RELATIONS: members found 229
FIELD_RELATIONS TOTAL: 999 for F007
[QX_DIAG] GRAPH MOUNT
centerId: ac48f178-6158-4a4b-9aae-f47de8cde01b
relationCount: 999
corpusNodeCount: 0

[QX_DIAG] GRAPH SVG READY

[QX_DIAG] GRAPH BOOTSTRAP START
relationCount: 999
corpusNodeCount: 0

[QX_DIAG] GRAPH BOOTSTRAP COMPLETE
nodeCount: 282
edgeCount: 991

[QX_DIAG] GRAPH CORPUS LOADED 100
```

Interpretation:

1. The graph is mounting and bootstrapping before the corpus node cache is ready. It starts with `corpusNodeCount: 0`, then later logs `GRAPH CORPUS LOADED 100`.

2. Field identity is split between UUID-like IDs and canonical field codes such as `F007`.

3. The graph sees `229` field members and `999` relations, but bootstrap produces `282` nodes and `991` edges. That means relation endpoints, field members, and rendered graph nodes are not trivially identical sets.

4. A graph rendering success is not enough. It may still be semantically wrong if the graph bootstraps with incomplete corpus metadata or mismatched IDs.

5. The graph has a diagnostic harness:

```js
window.__QX_GRAPH_REPORT__()
```

This harness is useful for inspection but is not itself the fix.

Likely graph failure class:

```text
identity mismatch + async ordering/race + projection mismatch
```

Do not “clean up the graph” broadly. Any graph patch must state which identity layer it is normalizing:

```text
field UUID
F### field code
openai-* artifact id
source_thread_id
relation endpoint id
corpus node id
```

## 8. Do-not-do list

Do not invent new schema.

Do not add a new classification source.

Do not make Supabase canonical.

Do not rewrite the Classify page.

Do not modify write paths during the read-path bridge.

Do not collapse the graph and classify problems together.

Do not assume `openai-*` IDs are drawer-membership keys.

Do not assume a rendered graph is semantically correct.

Do not ask David to restate the whole project.

## 9. Immediate useful response expected from you

Given this state, the highest-value response is one of the following:

### Option A — Classify bridge patch

Provide one applicable script or one direct patch that updates:

```text
apps/quasantum/src/pages/Classify.tsx
```

to fetch `field.v2.json`, bridge `artifact.id` to `source_thread_id`, and resolve canonical membership correctly.

Constraints:

```text
read path only
preserve handleSave
preserve selectArtifact
graceful fallback if canonical JSON fetch fails
buildable TypeScript
```

### Option B — Review a pasted patch

If David pastes a script, review whether it correctly:

```text
adds CANONICAL_FIELD_URL
loads field.v2.json
creates CanonicalFieldEntry / CanonicalFieldV2 types
extends Promise.all
passes canonicalFieldEntries into findCanonicalMembership
sets source_thread_id from fieldEntry
preserves write paths
```

### Option C — Graph diagnostic only

If David explicitly switches back to Relations graph, ask for the output of:

```js
window.__QX_GRAPH_REPORT__()
```

and inspect only:

```text
field id normalization
relation endpoint ids
node id set
missing node metadata
bootstrap order
corpus load timing
```

Do not broaden beyond that.

## 10. Current thread focus

The current task is still:

```text
wire the Classify tab
```

The immediate target is to make this row classify correctly:

```text
LEITMOTIF ABC I-P BUILD
openai-0543
source_thread_id 6876807a
dao / canonical / 0.45-0.30-0.25
```

Once that works, the same band should classify adjacent visible artifacts that share `source_thread_id: 6876807a`, including:

```text
ACT2a (Ch.7-9) PERP Expansion
TOP TIER COMMANDS LIST
Create synthetic image
Motion Design Principles
Domain-8 Artifact Transfer
```

End of rehydration artifact.

ASSISTANT: DeepSeek’s artifact shows **moderate local coherence but stale global state**. It understood the first Classify read-path objective, correctly identified canonical fetch fallback risk, and preserved the write-path boundary. But it also produced a brittle script, included a TypeScript syntax defect, fell back to manual edits, and does **not** appear rehydrated on the later-discovered failure: `getFieldArtifacts()` strips `source_thread_id`, so `drawer-membership.v1.json` cannot match `openai-*` artifacts without the `field.v2.json` bridge. That means DeepSeek needs **Level 4 rehydration: high-context delta rehydration, not full project rehydration**. fileciteturn49file0

Use this as the rehydration artifact:

```text
DEEPSEEK REHYDRATION ARTIFACT
QUASANTUM / Master Index 5.3.0
Thread focus: Relations Graph context + current Classify tab wiring

You are being rehydrated into the QUASANTUM repo state after a partial Classify read-path patch and after several Relations Graph obstacles. Your prior artifact showed good local reasoning around canonical drawer membership, but you are missing the latest failure mode and the broader graph constraints. Treat this as a high-context delta rehydrate.

ACTIVE REPO / DEPLOY SURFACE

Primary repo:
C:\Users\david\Projects\RODZAKI.github.io

App path:
apps/quasantum

Primary source target right now:
apps/quasantum/src/pages/Classify.tsx

Static deploy target:
quasantum/

Build output:
dist/quasantum/

Build command:
cd "C:\Users\david\Projects\RODZAKI.github.io\apps\quasantum"
npm run build

Windows deploy sync:
$src = "C:\Users\david\Projects\RODZAKI.github.io\dist\quasantum"
$dst = "C:\Users\david\Projects\RODZAKI.github.io\quasantum"
if (Test-Path $dst) { Remove-Item $dst -Recurse -Force }
Copy-Item $src $dst -Recurse

Do not use POSIX `cp` as the primary deploy command on this machine. A previous Bash path attempt failed on Windows path escaping.

CURRENT THREAD SCOPE

Current concentration:
Wire the Classify tab.

Do not drift into unrelated graph rewrites, auth, billing, UI polish, Supabase schema changes, or destructive refactors.

The Classify tab should become a canonical-read surface:
- Load field artifacts.
- Load canonical classification from JSON.
- Display canonical primary drawer, row class, and weights.
- Keep Supabase write paths intact only as projection/steward override behavior.
- Do not re-derive classification from stale Supabase state.

CURRENT CLASSIFY STATE

First Classify read-path patch already landed.

It did:
- Removed the ad hoc Supabase REST re-query against corpus_threads from Classify.tsx.
- Added getCanonicalDrawerMembership().
- Fetched:
https://rodzaki.github.io/apex/canon/drawer-membership.v1.json
- Used canonical-first merge logic.
- Lookup cascade was:
artifact.source_thread_id
artifact.source_thread_id?.slice(0, 8)
artifact.id
- Preserved selectArtifact().
- Preserved handleSave().
- Preserved all Supabase write behavior.

Build/deploy succeeded.
Commit:
29bc4cb
Bundle observed:
index-k9ARqmA5.js
Master Index advanced:
0.0.517 -> 0.0.518

However, visual validation still showed Classify rows as unclassified.

LATEST CLASSIFY FAILURE MODE

The first patch is conceptually correct but cannot match because the artifact rows reaching Classify do not carry source_thread_id.

Current service issue:
getFieldArtifacts() queries corpus_threads with a narrow select similar to:
id, title, content, field_id, created_at

Therefore toFieldArtifactItem() maps:
source_thread_id: item.source_thread_id ?? null

But item.source_thread_id is missing because it was not selected.

For LEITMOTIF ABC I-P BUILD:
artifact.id = openai-0543
artifact.source_thread_id = null or undefined in Classify

So the matcher candidates collapse to:
undefined
undefined
openai-0543

But drawer-membership.v1.json is keyed by short source-thread IDs, not by openai-* artifact IDs.

The needed canonical key is:
6876807a

Canonical membership expected for 6876807a:
primary_drawer: dao
row: canonical
drawer_weights:
dao: 0.45
mitakuye-oyasin: 0.30
maat: 0.25

The missing bridge is field.v2.json:
https://rodzaki.github.io/apex/canon/field.v2.json

field.v2.json maps:
openai-0543 -> source_thread_id 6876807a

For LEITMOTIF ABC I-P BUILD:
id: openai-0543
source_thread_id: 6876807a
title: LEITMOTIF ABC I-P BUILD
era: openai
primary_drawer: dao
row: canonical
drawer_weights:
dao: 0.45
mitakuye-oyasin: 0.30
maat: 0.25

NEXT REQUIRED CLASSIFY PATCH

Patch Classify.tsx to load BOTH:
drawer-membership.v1.json
field.v2.json

Add canonical field entry support:
type CanonicalFieldEntry = {
id: string;
source_thread_id?: string | null;
title?: string;
era?: string | null;
primary_drawer?: DrawerId | null;
drawers?: DrawerId[];
row?: RowClass;
drawer_weights?: Partial<Record<DrawerId, number>>;
};

type CanonicalFieldV2 = {
field_version: string;
generated_at?: string;
basis?: string;
entries?: CanonicalFieldEntry[];
};

Add:
getCanonicalFieldEntries()

It should fetch:
https://rodzaki.github.io/apex/canon/field.v2.json

It should return:
Map<string, CanonicalFieldEntry>
keyed by:
entry.id

Update Promise.all:
const [artifactRows, drawerRows, canonicalMemberships, canonicalFieldEntries] =
await Promise.all([
getFieldArtifacts(fieldId),
getDrawers(),
getCanonicalDrawerMembership(),
getCanonicalFieldEntries(),
]);

Update matcher cascade:
artifact.source_thread_id
artifact.source_thread_id?.slice(0, 8)
fieldEntry?.source_thread_id
fieldEntry?.source_thread_id?.slice(0, 8)
artifact.id

If drawer-membership.v1.json still has no match, fall back to the field.v2 entry itself if it contains primary_drawer or drawer_weights.

Merge should set:
source_thread_id: artifact.source_thread_id ?? fieldEntry?.source_thread_id ?? null
era: artifact.era ?? fieldEntry?.era ?? null
drawer_weights: canonical drawer weights first
primary_drawer: canonical primary first
row_class: canonical.row ?? artifact.row_class ?? "canonical"
classification_status: canonical ? "classified" : fallback

Do not modify:
selectArtifact()
handleSave()
assignArtifactToDrawer()
removeArtifactFromDrawer()
updateArtifactClassification()
Supabase write behavior

Optional upstream improvement:
In services.ts, expand getFieldArtifacts() corpus_threads select to include:
source_thread_id,
master_index_num,
classification_status,
primary_drawer,
drawer_weights,
row_class,
confidence,
alignment_flag,
resolving,
state,
era

But the real fix is the canonical field.v2 bridge, because it keeps Classify independent of Supabase completeness.

EXPECTED CLASSIFY VALIDATION

Route:
https://rodzaki.github.io/quasantum/#/q/fields/F007

Open:
Classify tab

Select:
LEITMOTIF ABC I-P BUILD

Expected:
primary_drawer: dao
row_class: canonical
classification_status: classified
dao: 0.45
mitakuye-oyasin: 0.30
maat: 0.25

Adjacent artifacts in same canonical band should also classify as dao:
ACT2a (Ch.7-9) PERP Expansion
TOP TIER COMMANDS LIST
Create synthetic image
Motion Design Principles
Domain-8 Artifact Transfer

RELATIONS GRAPH CONTEXT / OBSTACLES

Relations Graph has been the major obstacle before this Classify focus. Do not regress it.

Observed working/diagnostic state on F007:
FIELD_RELATIONS: resolved field id -> F007
FIELD_RELATIONS: membership found 229
FIELD_RELATIONS TOTAL: 999 for F007
[QX_DIAG] GRAPH MOUNT
relationCount: 999
corpusNodeCount: 0 at initial mount
GRAPH SVG READY
GRAPH BOOTSTRAP START
GRAPH BOOTSTRAP COMPLETE
nodeCount: 282
edgeCount: 991
GRAPH CORPUS LOADED 100

Important graph obstacles encountered:
1. Field identity mismatch:
Routes and some surfaces use UUIDs.
Canonical field operations often resolve to string code F007.
Relations graph must resolve field id correctly before querying.

2. Field membership source:
Field artifacts are not simply corpus_threads.field_id by UUID.
The surface depends on artifact_fields membership for F007.

3. Relation volume:
F007 currently has about 999 relations.
Graph rendering must avoid blank-state assumptions and must tolerate high relation count.

4. Bootstrap mismatch:
Initial graph mount may show corpusNodeCount 0, then later bootstrap constructs nodes.
Do not interpret initial corpusNodeCount 0 as final graph failure.

5. Node/edge discrepancy:
Observed complete graph state was roughly:
nodeCount: 282
edgeCount: 991
while relations total was 999.
This can reflect missing endpoints, dedupe, hidden/self relations, or filtered edges.
Do not “fix” by forcing relation count and edge count to match without diagnostics.

6. Graph harness:
QX harness and console diagnostics have been useful.
Preserve QX_DIAG behavior unless explicitly asked to remove it.

7. Blank/white route issue:
A blank screen was observed on:
#/thread/openai-0543
That was ThreadView, not the Classify tab.
Do not treat ThreadView blankness as a Classify read-path failure.

8. Center identity:
Graph logs showed a UUID-like centerId while relation queries resolved to F007.
Be careful not to collapse these identities incorrectly.

9. Cache/deploy confusion:
Browser asset caching and GitHub Pages delay can obscure validation.
Always verify current bundle name in devtools before assuming source patch failure.

RELATIONS GRAPH DO-NOT-TOUCH RULES FOR THIS THREAD

Unless explicitly instructed:
- Do not rewrite RelationGraphV2.
- Do not change relation cache semantics.
- Do not change relation schema.
- Do not alter field id resolution in FieldDetail unless required by Classify.
- Do not remove graph diagnostics.
- Do not reduce relation count artificially.
- Do not change F007 membership behavior.

SCRIPT QUALITY REQUIREMENTS

Your previous artifact produced a useful conceptual patch but included issues:
- TypeScript syntax risk in Promise<Map<...>>.
- Over-broad regexes that could delete unintended code.
- POSIX cp command unsuitable for Windows default execution.
- Insufficient awareness of the second-stage source_thread_id bridge failure.

For future scripts:
- Make a timestamped backup.
- Use precise string or AST-like replacements.
- Abort if expected anchors are missing.
- Do not use broad regexes spanning unrelated blocks.
- Use PowerShell-compatible deploy sync or Node fs.rmSync/fs.cpSync.
- Build before commit.
- Stage source + quasantum static deploy output.
- Commit and push only if staged changes exist.

CURRENT PATCH PRIORITY

Highest priority:
Implement Classify field.v2 bridge.

Second priority:
Optionally widen getFieldArtifacts() select to preserve source_thread_id and classification fields.

Out of scope right now:
Relations graph rewrite.
ThreadView blank page.
Supabase schema migration.
Auth.
Billing.
Styling polish.

SUCCESS DEFINITION

Classify tab on F007 must show LEITMOTIF ABC I-P BUILD as classified:

dao
canonical
dao 0.45
mitakuye-oyasin 0.30
maat 0.25

If it still shows unclassified after the field.v2 bridge:
Inspect the merged artifact object in console.
Confirm canonicalFieldEntries.get("openai-0543").
Confirm source_thread_id becomes 6876807a.
Confirm canonicalMemberships.get("6876807a").
Confirm selected row is using the merged artifact, not stale pre-merge artifact state.
```

Use that with DeepSeek as-is.