Merge pull request #75 from lossless-group/hygene/test-coverage

test(test-coverage): the corpora-builder harmony suite — 43 tests across ten groups, and the bugs they caught

Author: mpstaton

README.md

@@ -151,6 +151,35 @@ pnpm preview      # Preview the production build
 
 The `scripts/dev.sh` script prints the full URL list on start.
 
+## Testing
+
+Run the whole suite — every package plus the id-didi-sh identity contract — with one command:
+
+```bash
+pnpm test:all
+```
+
+That runs `scripts/test-all.sh`: each vitest package in turn, the end-to-end backend-chain integration, and (if `mix` is present) id-didi-sh's ExUnit suite in the sibling repo — ending with a grand-total tally (e.g. `✅ ALL SUITES PASSED — 67 tests across 7 suites`).
+
+Of that total, **43 tests across ten groups** are the corpora-builder coverage added in this effort — tracked in human language in [`context-v/specs/Corpora-Builder-Harmony-Test-Registry.md`](context-v/specs/Corpora-Builder-Harmony-Test-Registry.md), where each test's name is the ✓-phrase you see go green. The remainder is id-didi-sh's pre-existing suite, which `mix test` runs alongside this effort's Group A.
+
+Run a single group directly with `pnpm test` in its package:
+
+| Group | Command (`cd` then `pnpm test`) | What it covers |
+|---|---|---|
+| C | `packages/workspace` | client transport resilience (the property test that caught the reconnect bug) |
+| B, D, H | `services/workspace` | session tenancy, workspace registry, chat corpora slab |
+| E, J | `services/record-surrealdb-resolver` | canonical CRUD + the alignment-audit diff |
+| F | `services/content-ingest` | corpus markdown files |
+| G | `apps/strategy-curator` | curator surface state (Svelte 5 runes) |
+| I | `e2e` | full backend chain over a real WebSocket |
+
+Notes:
+
+- **Nothing touches the shared cloud.** Canonical-layer tests spin a throwaway in-memory SurrealDB; temp dirs stand in for the clients volume. The only thing that reads the real cloud is the read-only **corpora-alignment audit** (`node scripts/audit-corpora-alignment.mjs`) — it flags DB↔disk drift and changes nothing; it's not part of `test:all`'s pass/fail.
+- **The E2E group (I)** stands up a disposable backend (throwaway Docker NATS + in-memory SurrealDB + the resolver, workspace-service, and content-ingest) and tears it down after — so it needs **Docker running** and the `surreal` CLI. It uses ports `3199`/`4223`; if an interrupted run leaves anything behind, clear it with `docker rm -f augment-e2e-nats` and `pkill -f "tsx src/server.ts"`.
+- **No `ws` package** — the transport tests run against a hand-rolled RFC-6455 server and every client uses the platform-native `WebSocket`.
+
 ## Deployment
 
 The humain-vc single-tenant instance runs live on **Railway** at

apps/strategy-curator/package.json

@@ -7,7 +7,8 @@
     "dev": "rsbuild dev",
     "build": "rsbuild build",
     "preview": "rsbuild preview",
-    "check": "svelte-check --tsconfig ./tsconfig.json"
+    "check": "svelte-check --tsconfig ./tsconfig.json",
+    "test": "vitest run"
   },
   "dependencies": {
     "@augment-it/theme": "workspace:*",
@@ -19,7 +20,10 @@
     "@module-federation/rsbuild-plugin": "^2.6.0",
     "@rsbuild/core": "^2.1.2",
     "@rsbuild/plugin-svelte": "^2.0.0",
+    "@sveltejs/vite-plugin-svelte": "^5.1.1",
+    "jsdom": "^30.0.1",
     "svelte-check": "^4.7.1",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "vitest": "^3.2.7"
   }
 }

apps/strategy-curator/test/curation.test.ts

@@ -0,0 +1,149 @@
+// Group G — Curator surface state.
+// Registry: context-v/specs/Corpora-Builder-Harmony-Test-Registry.md
+//
+// Test names are the registry's ✓-phrases, verbatim. The curator is a
+// Svelte 5 runes singleton; tests run it under the svelte plugin + jsdom
+// with @augment-it/workspace mocked, and reset the singleton's state per
+// test. This is the client half of the humain-vc "wrong domain type" bug.
+
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+// A mutable stand-in for the workspace singleton — tests reconfigure its
+// fields and its invoke spy per case.
+const ws = {
+  workspaces: [] as Array<{ client_id: string; default_domain_type: string; display_name: string; has_env: boolean; org_id: string | null }>,
+  active_client_id: null as string | null,
+  connect: vi.fn(),
+  loadWorkspaces: vi.fn(async () => {}),
+  activateWorkspace: vi.fn(async (_id: string) => {}),
+  invoke: vi.fn(async (_cap: string, _args: unknown) => ({}) as unknown),
+};
+
+vi.mock('@augment-it/workspace', () => ({
+  workspace: ws,
+  WORKSPACE_CHANGED_EVENT: 'workspace-changed',
+}));
+
+// Imported once; the constructor registers the cross-remote window listener.
+const { curation } = await import('../src/curation.svelte.ts');
+
+const wsSummary = (client_id: string, default_domain_type: string) => ({
+  client_id,
+  default_domain_type,
+  display_name: client_id,
+  has_env: true,
+  org_id: null,
+});
+
+/** Route invoke by capability so select()'s domain.assemble + tag.suggest
+ *  don't blow up while a test focuses on domain.list. */
+const routedInvoke = (domains: Array<{ slug: string; title: string; tags: string[] }>) =>
+  vi.fn(async (cap: string) => {
+    if (cap === 'domain.list') return { domains };
+    if (cap === 'domain.assemble') return { sources: [] };
+    if (cap === 'tag.suggest') return { tags: [] };
+    return {};
+  });
+
+const settle = () => new Promise((r) => setTimeout(r, 25));
+
+beforeEach(() => {
+  curation.clientSlug = null;
+  curation.domainType = 'strategy';
+  curation.strategies = [];
+  curation.activeSlug = null;
+  curation.sources = [];
+  curation.lastError = null;
+  ws.workspaces = [];
+  ws.active_client_id = null;
+  ws.invoke = vi.fn(async () => ({ domains: [] }));
+  ws.activateWorkspace = vi.fn(async () => {});
+  localStorage.clear();
+});
+
+describe('Group G — curator surface state', () => {
+  test('bootstrap resolves the active workspace’s default domain type before the first domain.list fires', async () => {
+    ws.active_client_id = 'humain-vc';
+    ws.workspaces = [wsSummary('humain-vc', 'thesis')];
+    const invoke = vi.fn(async () => ({ domains: [] }));
+    ws.invoke = invoke;
+
+    await curation.bootstrap();
+
+    // The humain-vc bug in one assertion: the FIRST query must ask for
+    // thesis, not the flat 'strategy' fallback.
+    expect(curation.domainType).toBe('thesis');
+    expect(invoke).toHaveBeenCalledWith('domain.list', { type: 'thesis', client_slug: 'humain-vc' });
+  });
+
+  test('switching workspaces resets the list, the active corpus, and the domain type to the new workspace’s default', async () => {
+    // Start in humain-vc/thesis with loaded state.
+    curation.clientSlug = 'humain-vc';
+    curation.domainType = 'thesis';
+    curation.strategies = [{ slug: 'x', title: 'X', tags: [] }] as never;
+    curation.sources = [{}] as never;
+    curation.activeSlug = 'x';
+    ws.workspaces = [wsSummary('reach-edu', 'strategy')];
+    ws.invoke = routedInvoke([]);
+    // The real package dispatches WORKSPACE_CHANGED_EVENT on activate.
+    ws.activateWorkspace = vi.fn(async (id: string) => {
+      window.dispatchEvent(new CustomEvent('workspace-changed', { detail: { client_id: id } }));
+    });
+
+    await curation.switchWorkspace('reach-edu');
+    await settle();
+
+    expect(curation.clientSlug).toBe('reach-edu');
+    expect(curation.domainType).toBe('strategy'); // reach-edu's default, not humain-vc's thesis
+    expect(curation.activeSlug).toBeNull();
+    expect(curation.sources).toEqual([]);
+  });
+
+  test('a workspace change broadcast from another remote re-scopes this surface too', async () => {
+    curation.clientSlug = 'humain-vc';
+    curation.domainType = 'thesis';
+    ws.workspaces = [wsSummary('reach-edu', 'strategy')];
+    ws.invoke = routedInvoke([]);
+
+    // No switchWorkspace call here — a sibling remote flipped the workspace
+    // and only the cross-remote event bridges to us.
+    window.dispatchEvent(new CustomEvent('workspace-changed', { detail: { client_id: 'reach-edu' } }));
+    await settle();
+
+    expect(curation.clientSlug).toBe('reach-edu');
+    expect(curation.domainType).toBe('strategy');
+  });
+
+  test('a handler error reply surfaces as a visible error, never as an empty rail', async () => {
+    curation.clientSlug = 'humain-vc';
+    curation.domainType = 'thesis';
+    ws.invoke = vi.fn(async () => ({ ok: false, error: 'resolver down' }));
+
+    await curation.loadStrategies();
+
+    // "broken" is distinguishable from "empty": empty rail AND a set error.
+    expect(curation.strategies).toEqual([]);
+    expect(curation.lastError).toMatch(/domain\.list/);
+    expect(curation.lastError).toMatch(/resolver down/);
+  });
+
+  test('a saved corpus selection is restored only if it exists in the freshly loaded list', async () => {
+    curation.clientSlug = 'humain-vc';
+    curation.domainType = 'thesis';
+
+    // Saved slug IS in the loaded list → restored.
+    localStorage.setItem('augment-it:active-strategy', 'consumer-immunology');
+    ws.invoke = routedInvoke([{ slug: 'consumer-immunology', title: 'Consumer Immunology', tags: [] }]);
+    await curation.loadStrategies();
+    await settle();
+    expect(curation.activeSlug).toBe('consumer-immunology');
+
+    // Saved slug is stale (not in the new list) → NOT restored.
+    curation.activeSlug = null;
+    localStorage.setItem('augment-it:active-strategy', 'ghost-from-another-workspace');
+    ws.invoke = routedInvoke([{ slug: 'consumer-immunology', title: 'Consumer Immunology', tags: [] }]);
+    await curation.loadStrategies();
+    await settle();
+    expect(curation.activeSlug).toBeNull();
+  });
+});

apps/strategy-curator/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+
+export default defineConfig({
+  plugins: [svelte({ compilerOptions: { runes: true } })],
+  test: { include: ['test/**/*.test.ts'], environment: 'jsdom', testTimeout: 10_000 },
+});

changelog/2026-07-30_01_Test-Coverage-Begins-And-Catches-A-Real-Reconnect-Bug-On-Day-One.md

@@ -0,0 +1,130 @@
+---
+title: "Test coverage begins — and catches a real reconnect bug on day one"
+lede: "augment-it gets its first automated tests: Vitest wired, nine tests green across the transport, the workspace registry, and didi's corpora slab. The headline property test — 'no invoke silently vanishes' — failed first exactly as the registry predicted, and the failure was real: the client reconnect chain died on any refused connection, a live mechanism behind the zombie-session and lost-corpus symptoms. Found by the test, fixed in the transport, now guarded forever."
+date_created: 2026-07-30
+date_modified: 2026-07-30
+publish: true
+authors:
+  - Michael Staton
+augmented_with:
+  - Claude Code on Claude Fable 5
+  - Claude Code on Claude Opus 4.8
+files_changed:
+  - packages/workspace/src/transport.ts
+  - packages/workspace/test/transport.test.ts
+  - packages/workspace/test/workspace-socket-test-server.ts
+  - packages/workspace/vitest.config.ts
+  - services/workspace/test/workspaces.test.ts
+  - services/workspace/test/chat-corpora-slab.test.ts
+  - services/workspace/src/chat.ts
+  - context-v/specs/Corpora-Builder-Harmony-Test-Registry.md
+---
+
+# Test coverage begins — and catches a real reconnect bug on day one
+
+## Why Care?
+
+For the entire life of augment-it, agents have written and rewritten this
+codebase with **zero automated tests** guarding it — verification was
+typechecks, builds, hand-run prove-scripts, and the operator walking the
+surface. That debt came due this month: humain-vc's corpora failing to
+load, corpus creations that never landed, a rail that renders "empty"
+indistinguishably from "broken." We couldn't tell a bug from an empty
+workspace because nothing asserted the difference.
+
+This is the first automated test coverage in the repo. And it earned its
+keep immediately: the very first property test we wrote failed on its
+first run — as the registry spec explicitly predicted it would — and the
+failure was not a test artifact. It was a **real reconnect bug in the
+client transport** that plausibly underlies the zombie-session and
+"invokes never reach the workspace" symptoms the operator has been
+hitting. The test found it; the fix closes it; the test now guards it.
+
+## The bug the test caught
+
+The client transport (`packages/workspace/src/transport.ts`) reconnects
+to the workspace-service after a dropped socket. But it only scheduled
+that reconnect from the WebSocket **`close`** handler. It turns out that
+when a connection is *refused* — the exact situation during a
+workspace-service restart or redeploy, when the browser's reconnect
+attempt hits a port with nothing listening — Node's native WebSocket
+(and, per spec, browsers too) fires **only `error`, never `close`**.
+
+So the reconnect chain died on the first failed attempt. A surface that
+lost its socket during a backend restart would never reconnect on its
+own; it stayed wedged until a full page reload. Invokes fired into that
+window hung to their 120-second deadline and then blamed the server —
+precisely the "the workspace did not reply" mystery. This is a strong
+candidate for one of the mechanisms behind
+[[Search-And-Add-Invokes-Never-Reach-The-Workspace]] and the
+zombie-session class.
+
+The fix: an `error` on a socket that never opened now runs the same
+reconnect tail the `close` handler does, guarded by a per-attempt flag so
+a browser that fires *both* `error` and `close` still schedules exactly
+one reconnect. Established-socket drops, auth-death (4401/4403), and
+deliberate `close()` all keep their existing behavior untouched.
+
+Visible proof it works: the property test's whole suite dropped from
+2.1s to 0.9s after the fix, because the invoke now reconnects promptly
+instead of hanging to its deadline.
+
+## What landed
+
+### The harness
+
+Vitest is wired as the repo's test runner (unit + service tiers;
+Playwright for the future E2E tier per the plan). `pnpm test` runs the
+repo's turbo `test` task; each package runs `vitest run`. No new runtime
+dependencies — the only additions are the test library itself. In
+particular, the transport tests needed a WebSocket server to connect to,
+and rather than pull the `ws` package back in (deliberately removed from
+this repo), the harness includes a small hand-rolled RFC-6455 endpoint
+over `node:http` — zero dependencies, mirroring the real
+workspace-service invoke/claim contract.
+
+### Group C — transport resilience (4 tests, `packages/workspace`)
+
+The registry's ✓-phrases, now green: no invoke silently vanishes across
+every socket-churn scenario (the one that caught the bug); a pre-open
+invoke is delivered exactly once after open; close 4401 fails all pending
+work immediately with "session expired"; and after auth-death the
+transport tries one silent refresh-reconnect, then waits — no storm. A
+timing seam was added to `transport.ts` so minutes-scale deadlines and
+backoff are assertable in milliseconds (production defaults unchanged).
+
+### Group D — workspace registry (3 tests, `services/workspace`)
+
+The `default_domain_type` resolution that suspect 1 hangs on —
+humain-vc's `thesis` vs the `strategy` fallback — plus `workspace.json`
+org_id winning over the `WORKSPACE_ORG_MAP` env fallback, and a
+.env-less workspace still listing with `has_env: false`. Each test builds
+a throwaway `clients/` root on disk and loads the module fresh, because
+the env map parses once at import.
+
+### Group H — didi's corpora slab (2 tests, `services/workspace`)
+
+The "Existing corpora" slab didi reads before resolving a corpus name:
+it lists every domain in the workspace regardless of type (the
+load-bearing difference from the curator rail's typed query), and it
+degrades to an empty slab — never a failed turn — when the resolver
+hiccups. Capability dispatch and NATS are mocked, so the contract is
+pinned without a live bus.
+
+## Where this sits
+
+Nine tests, three of the registry's ten MECE groups. Groups A (identity
+contract, ExUnit in id-didi-sh), B (session tenancy), E (canonical CRUD),
+F (corpus files), G (curator state), I (end-to-end), and J (the
+DB↔disk↔UI alignment audit) remain proposed in the registry, written as
+the ✓-phrases we want to see turn green next. The registry spec
+([[Corpora-Builder-Harmony-Test-Registry]]) tracks every one, Proposed or
+Implemented, with its purpose and location.
+
+## See also
+
+- [[Corpora-Builder-Harmony-Test-Registry]] — the living test registry
+- [[Test-Coverage-Harness-And-Regression-Floor]] — the harness plan
+- [[Troubleshooting-Workspace-DB-State-Alignment]] — the live bug hunt this serves
+- [[Search-And-Add-Invokes-Never-Reach-The-Workspace]] — the open issue this fix likely closes
+- [[Session-Expiry-Turns-The-App-Into-A-Zombie]] — the zombie class the reconnect bug feeds