fix(corpora-curator): the domain type stops filtering the list, so a slow workspace load can no longer hide every corpus (gh #88)

An operator on humain-vc opened the Corpora Curator and was told they had no
corpora. They have nine theses. The surface had guessed `strategy` for the
domain type, queried `domain.list` with it, got nothing back, and rendered "No
corpora yet" — a sentence indistinguishable from the truth.

Same symptom as the NATS-subject failure earlier this week, entirely different
cause, and this one is ours. The tell was visual rather than logged: the
workspace rendered as a pill instead of a `<select>` while the connection read
`open`, which has exactly one meaning — `workspace.list` never arrived while the
socket stayed healthy. `defaultDomainTypeFor` then fell through to its
`'strategy'` default and poisoned every call downstream.

We fixed this symptom once already, on 2026-07-07. That fix repaired the
SWITCHING path and left the guess in place, so the bug sat dormant for a month
waiting for `workspace.list` to be slow once. Guessing better is not a fix. The
fix is to stop needing the guess.

The list is no longer filtered. `domain.list` is called with `client_slug` only.
`listDomains` in the resolver has always declared `type` as optional and
projected it in the result, so omitting it is the supported shape — the client
was imposing a narrowing the backend never asked for. The types carry no
behavioural difference to narrow on; they are vocabulary preference, reach-edu
saying "strategy" where humain-vc says "thesis", and domains were abstracted
precisely so that any type shows up.

The type now travels with the corpus. A new `callType` getter reads
`active.type` — a property of the thing the operator clicked — and feeds
`domain.assemble`, every `source.*` and `tag.apply`, about fifteen call sites.
`domainType` demotes to the create form's default and nothing else, so a wrong
value can mis-prefill one visible text field the operator can see and change
rather than emptying the surface. The broadcast handler drops its type check for
the same reason, which also fixes a retype OUT of the active type being missed.

Selection keys on `(type, slug)`, because that is the real key —
"apprenticeship" can be a strategy AND a topic. `ACTIVE_STRATEGY_KEY` stores
`type:slug`; bare slugs from before this change still resolve, so nobody loses
their selection on upgrade. Each row grows a type chip so two same-slug corpora
stay tellable apart.

No backend change. Three regression tests pin it, including the one that
matters: a workspace whose summary never arrives at all still sees every corpus
it owns.

Files changed:
- apps/corpora-curator/src/curation.svelte.ts — callType, activeType, the
  unfiltered domain.list, the type:slug storage key
- apps/corpora-curator/src/App.svelte — broadcast handler loses its type check;
  the header pill reads the selected corpus's own type
- apps/corpora-curator/src/CorpusPicker.svelte — the Type field tracks the
  workspace preference until the operator overrides it; per-row type chip
- apps/corpora-curator/src/app.css — .cc-strat-meta, the row that carries it
- apps/corpora-curator/test/curation.test.ts — three regressions
- context-v/issues/Domain-Type-Is-Ambient-State-So-A-Failed-Workspace-Load-Hides-Every-Corpus.md
- changelog/2026-08-08_05_Same-Symptom-Second-Cause-The-Type-Filter-That-Hid-A-Whole-Workspace.md

Closes #88.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PZJvZWco3z7SR2dEhFqEjA

Author: mpstaton

apps/corpora-curator/src/App.svelte

@@ -38,8 +38,11 @@
         ev.subject === 'domain.retyped'
           ? (payload.client_slugs ?? []).includes(curation.clientSlug ?? '')
           : payload.client_slug === curation.clientSlug;
-      const touchesActiveType = payload.type === curation.domainType || payload.old_type === curation.domainType;
-      if (inThisClient && touchesActiveType) void curation.loadStrategies();
+      // No type check any more: the list holds every type in the workspace
+      // (gh #88), so any domain created or retyped in this client is relevant.
+      // The old filter also meant a retype OUT of the active type was missed
+      // whenever the guessed type was wrong.
+      if (inThisClient) void curation.loadStrategies();
     } else if (
       ev.subject === 'source.added' ||
       ev.subject === 'source.updated' ||
@@ -70,11 +73,16 @@
     {:else}
       <span class="cc-pill" title="Active workspace">{curation.clientSlug ?? '— no workspace —'}</span>
     {/if}
-    <span class="cc-pill" title="Active domain type">{curation.domainType}</span>
+    <!-- The selected corpus's OWN type when there is one; otherwise this
+         client's preferred vocabulary. It labels, it never filters (gh #88). -->
+    <span
+      class="cc-pill"
+      title={curation.active ? 'Type of the selected corpus' : 'This workspace’s preferred vocabulary for new corpora'}
+    >{curation.active?.type ?? curation.domainType}</span>
     {#if curation.active}
       <button
         class="cc-back"
-        onclick={() => (curation.activeSlug = null)}
+        onclick={() => { curation.activeSlug = null; curation.activeType = null; }}
         title="Back to the corpora list / create form"
       >‹ All corpora</button>
       <span class="cc-strategy">{curation.active.title}</span>

apps/corpora-curator/src/CorpusPicker.svelte

@@ -18,7 +18,17 @@
   let title = $state('');
   let slug = $state('');
   let slugEdited = $state(false);
+  // A one-time snapshot here was the last visible trace of gh #88: this
+  // component mounts before workspace.list resolves, so humain-vc's create form
+  // offered "strategy" while every other surface had corrected itself to
+  // "thesis". Track the workspace's preference until the operator overrides it;
+  // once they type, their value wins and stops moving under them.
   let type = $state(curation.domainType);
+  let typeEdited = $state(false);
+  $effect(() => {
+    const preferred = curation.domainType;
+    if (!typeEdited) type = preferred;
+  });
   let tagInput = $state('');
   let pendingTags = $state<string[]>([]);
   let tagSuggest = $derived(curation.suggestTags(tagInput));
@@ -43,12 +53,12 @@
   }
   async function create(): Promise<void> {
     await curation.createStrategy({ title, slug, tags: pendingTags, type });
-    // Read domainType back AFTER the await — createStrategy only updates it
-    // (via setDomainType) once the server confirms a type change, so
-    // resetting eagerly here would just re-read the pre-create value.
+    // The form goes back to the workspace's preference after a create — a type
+    // the operator typed for ONE corpus should not become sticky for the next.
     title = '';
     slug = '';
     slugEdited = false;
+    typeEdited = false;
     type = curation.domainType;
     pendingTags = [];
     tagInput = '';
@@ -65,9 +75,15 @@
     <ul class="cc-strat-list">
       {#each curation.strategies as s (s.slug)}
         <li>
-          <button class="cc-strat" onclick={() => curation.select(s.slug)}>
+          <!-- The type rides along on the row rather than filtering the list
+               (gh #88). Two corpora can share a slug across types, so the chip
+               is also what makes them distinguishable. -->
+          <button class="cc-strat" onclick={() => curation.select(s.slug, s.type)}>
             <span class="cc-strat-title">{s.title}</span>
-            <span class="cc-muted cc-mono cc-mini">{s.slug}</span>
+            <span class="cc-strat-meta">
+              <span class="cc-muted cc-mono cc-mini">{s.slug}</span>
+              {#if s.type}<span class="cc-status-chip">{s.type}</span>{/if}
+            </span>
           </button>
         </li>
       {/each}
@@ -85,7 +101,12 @@
 
   <div class="cc-field">
     <span class="cc-label">Type <span class="cc-muted cc-mini">— any value; 'strategy' and 'thesis' are the two in use today</span></span>
-    <input class="cc-mono" bind:value={type} placeholder="strategy" />
+    <input
+      class="cc-mono"
+      value={type}
+      oninput={(e) => { typeEdited = true; type = e.currentTarget.value; }}
+      placeholder={curation.domainType}
+    />
   </div>
 
   <div class="cc-field">

apps/corpora-curator/src/app.css

@@ -167,6 +167,9 @@
 .cc-app .cc-strat-list { list-style: none; margin: 0.5rem 0; padding: 0; display: flex; flex-direction: column; gap: 0.3rem; }
 .cc-app .cc-strat { width: 100%; text-align: left; display: flex; flex-direction: column; gap: 2px; }
 .cc-app .cc-strat-title { font-weight: 600; }
+/* Slug + type on one line. The type chip is load-bearing: the list holds every
+   type at once (gh #88) and (type, slug) is the real key. */
+.cc-app .cc-strat-meta { display: flex; align-items: center; gap: 0.4rem; flex-wrap: wrap; }
 .cc-app .cc-create { display: flex; gap: 0.4rem; margin-top: 0.75rem; }
 
 /* ---- source list ---- */