zooid 0.8.0 → 0.9.1

package/src/commands/init.test.ts

@@ -19,12 +19,11 @@ function loadYaml(path: string): unknown {
 }
 
 describe('runInit — claude subscription path', () => {
-  it('writes yaml + AGENTS.md + .claude/settings.json + .gitignore (no .env, no opencode.json)', async () => {
+  it('writes yaml + AGENTS.md + .claude/settings.json + .gitignore (no model, no .env, no opencode.json)', async () => {
     await runInit({
       dir,
       preset: 'claude',
       auth: 'subscription',
-      model: 'claude-sonnet-4-6',
     })
 
     expect(existsSync(join(dir, 'zooid.yaml'))).toBe(true)
@@ -36,11 +35,20 @@ describe('runInit — claude subscription path', () => {
     expect(existsSync(join(dir, 'agents/zooid-assistant/opencode.json'))).toBe(false)
 
     const cfg = loadYaml(join(dir, 'zooid.yaml')) as {
-      agents: { 'zooid-assistant': { acp: { preset: string; model: string } } }
+      agents: { 'zooid-assistant': { acp: { preset: string; model?: string } } }
+    }
+    // No model — the harness chooses its own default.
+    expect(cfg.agents['zooid-assistant'].acp).toEqual({ preset: 'claude' })
+  })
+
+  it('pins a model when --model is passed', async () => {
+    await runInit({ dir, preset: 'claude', auth: 'subscription', model: 'claude-opus-4-8' })
+    const cfg = loadYaml(join(dir, 'zooid.yaml')) as {
+      agents: { 'zooid-assistant': { acp: { preset: string; model?: string } } }
     }
     expect(cfg.agents['zooid-assistant'].acp).toEqual({
       preset: 'claude',
-      model: 'claude-sonnet-4-6',
+      model: 'claude-opus-4-8',
     })
   })
 })
@@ -51,7 +59,6 @@ describe('runInit — claude api-key path', () => {
       dir,
       preset: 'claude',
       auth: 'api-key',
-      model: 'claude-sonnet-4-6',
       apiKey: 'sk-ant-xyz',
     })
 
@@ -60,12 +67,11 @@ describe('runInit — claude api-key path', () => {
 })
 
 describe('runInit — opencode opencode-go path', () => {
-  it('writes opencode.json with opencode-go provider + env-interpolated apiKey', async () => {
+  it('writes opencode.json with opencode-go provider + env-interpolated apiKey, no model', async () => {
     await runInit({
       dir,
       preset: 'opencode',
       provider: 'opencode-go',
-      model: 'kimi-k2.6',
       apiKey: 'sk-opencode-zzz',
     })
 
@@ -73,7 +79,8 @@ describe('runInit — opencode opencode-go path', () => {
     const oc = JSON.parse(
       readFileSync(join(dir, 'agents/zooid-assistant/opencode.json'), 'utf8'),
     )
-    expect(oc.model).toBe('opencode-go/kimi-k2.6')
+    // No model — opencode picks its own default (e.g. bigpickle).
+    expect(oc).not.toHaveProperty('model')
     expect(oc.provider['opencode-go'].options.apiKey).toBe('{env:OPENCODE_API_KEY}')
     expect(oc.permission.webfetch).toBe('allow')
 
@@ -90,7 +97,7 @@ describe('runInit — idempotency', () => {
   it('errors on non-empty dir without --force', async () => {
     writeFileSync(join(dir, 'preexisting.txt'), 'x')
     await expect(
-      runInit({ dir, preset: 'claude', auth: 'subscription', model: 'claude-sonnet-4-6' }),
+      runInit({ dir, preset: 'claude', auth: 'subscription' }),
     ).rejects.toThrow(/non-empty/i)
   })
 
@@ -99,7 +106,7 @@ describe('runInit — idempotency', () => {
     writeFileSync(join(dir, 'pnpm-lock.yaml'), 'lockfileVersion: 9')
     require('node:fs').mkdirSync(join(dir, 'node_modules'))
     require('node:fs').mkdirSync(join(dir, '.git'))
-    await runInit({ dir, preset: 'claude', auth: 'subscription', model: 'claude-sonnet-4-6' })
+    await runInit({ dir, preset: 'claude', auth: 'subscription' })
     expect(existsSync(join(dir, 'zooid.yaml'))).toBe(true)
   })
 
@@ -109,7 +116,6 @@ describe('runInit — idempotency', () => {
       dir,
       preset: 'claude',
       auth: 'subscription',
-      model: 'claude-sonnet-4-6',
       force: true,
     })
     expect(readFileSync(join(dir, 'zooid.yaml'), 'utf8')).toContain('preexisting: true')
@@ -122,7 +128,6 @@ describe('runInit — idempotency', () => {
       dir,
       preset: 'claude',
       auth: 'subscription',
-      model: 'claude-sonnet-4-6',
       force: true,
       overwrite: true,
     })

package/src/commands/init.ts

@@ -21,9 +21,9 @@ export interface InitOptions {
   preset: 'claude' | 'codex' | 'opencode'
   /** Required for claude/codex; ignored for opencode. */
   auth?: 'subscription' | 'api-key'
-  /** Required for claude/codex; required for opencode (paired with `provider`). */
+  /** Optional model pin. Omitted by default — the harness uses its own default. */
   model?: string
-  /** Required for opencode. */
+  /** opencode provider id; defaults to `opencode-go` in the wizard. */
   provider?: string
   /** Required on api-key path; required for opencode. */
   apiKey?: string
@@ -68,7 +68,6 @@ export async function runInit(opts: InitOptions): Promise<void> {
   const writes: WriteSpec[] = []
 
   if (opts.preset === 'claude' || opts.preset === 'codex') {
-    if (!opts.model) throw new Error(`--model is required for preset ${opts.preset}`)
     if (!opts.auth) throw new Error('--auth (subscription|api-key) is required for claude/codex')
     const meta = findSimplePreset(opts.preset)!
 
@@ -101,7 +100,6 @@ export async function runInit(opts: InitOptions): Promise<void> {
     const isCustom = opts.provider === 'custom'
     const providerMeta = isCustom ? undefined : findOpencodeProvider(opts.provider)
     if (!isCustom && !providerMeta) throw new Error(`unknown opencode provider: ${opts.provider}`)
-    if (!isCustom && !opts.model) throw new Error('--model is required (paired with --provider)')
     if (!isCustom && !opts.apiKey) throw new Error('--api-key is required for opencode')
 
     writes.push({ path: 'zooid.yaml', content: generateZooidYaml({ preset: 'opencode' }) })

package/src/daemon/pull-wiring.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest'
+import { shouldBindHttpListener } from './pull-wiring.js'
+
+describe('shouldBindHttpListener', () => {
+  it('binds in appservice (push) mode — homeserver pushes to the daemon', () => {
+    expect(shouldBindHttpListener('appservice')).toBe(true)
+  })
+  it('does NOT bind in client (pull) mode — daemon polls outbound /sync', () => {
+    expect(shouldBindHttpListener('client')).toBe(false)
+  })
+  it('defaults to binding when mode is undefined', () => {
+    expect(shouldBindHttpListener(undefined)).toBe(true)
+  })
+})

package/src/daemon/pull-wiring.ts

@@ -0,0 +1,4 @@
+/** Push (`appservice`) binds an inbound listener; pull (`client`) does not. */
+export function shouldBindHttpListener(mode: 'appservice' | 'client' | undefined): boolean {
+  return mode !== 'client'
+}

package/src/daemon/start-daemon-pull.integration.test.ts

@@ -0,0 +1,95 @@
+import { mkdtempSync, rmSync, writeFileSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { startDaemon } from './start-daemon.js'
+
+let dir: string
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'zooid-pull-'))
+})
+afterEach(() => rmSync(dir, { recursive: true, force: true }))
+
+const delay = (ms: number) => new Promise((r) => setTimeout(r, ms))
+
+// Permissive stub: bootstrap CS calls all succeed with a benign body; the
+// /sync endpoint returns one page (carrying next_batch `s-1`) then idles. The
+// idle page is *paced* (~150ms) to mimic the long-poll — SyncLoop.run() has no
+// inter-tick delay, so an instant stub would busy-loop. This proves the daemon
+// selects + drives the pull loop; event→runTurn dispatch is covered in ZOD064.
+function pullFetchStub() {
+  let synced = false
+  return vi.fn(async (input: string | URL) => {
+    const url = new URL(typeof input === 'string' ? input : input.toString())
+    if (url.pathname === '/_matrix/client/v3/sync') {
+      if (synced) {
+        await delay(150)
+        return new Response(JSON.stringify({ next_batch: 's-idle', rooms: { join: {} } }), {
+          status: 200,
+        })
+      }
+      synced = true
+      return new Response(JSON.stringify({ next_batch: 's-1', rooms: { join: {} } }), {
+        status: 200,
+      })
+    }
+    if (url.pathname.endsWith('/account/whoami')) {
+      return new Response(JSON.stringify({ user_id: '@laptop:zoon.eco' }), { status: 200 })
+    }
+    // createRoom / register / join / send / state — benign shapes.
+    if (url.pathname.endsWith('/createRoom')) {
+      return new Response(JSON.stringify({ room_id: '!stub:zoon.eco' }), { status: 200 })
+    }
+    return new Response('{}', { status: 200 })
+  }) as unknown as typeof globalThis.fetch
+}
+
+describe('startDaemon — matrix client (pull) mode', () => {
+  it('binds no HTTP listener, runs the sync loop, persists a cursor, stops cleanly', async () => {
+    const yamlPath = join(dir, 'zooid.yaml')
+    writeFileSync(
+      yamlPath,
+      [
+        'runtime: local',
+        'workstation: laptop',
+        'transports:',
+        '  matrix:',
+        '    homeserver: https://zoon.eco',
+        '    mode: client',
+        '    as_token: test-as-token',
+        '    hs_token: test-hs-token',
+        'agents:',
+        '  docs:',
+        '    workdir: .',
+        '    acp: { preset: claude }',
+        '    matrix:',
+        '      transport: matrix',
+        "      rooms: ['#general']",
+      ].join('\n'),
+    )
+
+    const agentsDir = join(dir, 'data', 'agents')
+    const handle = await startDaemon({
+      configPath: yamlPath,
+      installSignalHandlers: false,
+      agentsDir,
+      fetch: pullFetchStub(),
+    })
+
+    // (a) No inbound listener in pull mode.
+    expect(handle.port).toBe(0)
+    expect(handle.agentNames).toEqual(['docs'])
+
+    // (c) Cursor persisted for the agent after a sync page is consumed, beside
+    //     sessions.json under <agentsDir>/<agentName>/. run() ticks async.
+    const sincePath = join(agentsDir, 'docs', 'sync-since')
+    await vi.waitFor(() => expect(existsSync(sincePath)).toBe(true), {
+      timeout: 3000,
+      interval: 50,
+    })
+
+    // (b) Clean, idempotent shutdown stops the loop (no hanging long-poll).
+    await handle.stop()
+    await handle.stop()
+  })
+})

package/src/daemon/start-daemon.ts

@@ -24,6 +24,7 @@ import {
   startWorkforcePublisher,
   type AgentBinding,
   type PublisherHandle,
+  type SyncLoop,
 } from '@zooid/transport-matrix'
 import {
   SpawnRegistry,
@@ -32,6 +33,8 @@ import {
 } from '@zooid/context-mcp'
 import { buildAcpRegistry } from '../build-registry.js'
 import { prepullImages } from '../prepull-images.js'
+import { makeSyncCursorStore } from './sync-cursors.js'
+import { shouldBindHttpListener } from './pull-wiring.js'
 
 export interface StartDaemonOpts {
   configPath?: string
@@ -66,6 +69,11 @@ export interface StartDaemonOpts {
    * task instead of leaving the user staring at an unmoving spinner.
    */
   prepullLog?: (line: string) => void
+  /**
+   * Override the global fetch used by the daemon's MatrixClient. Test seam for
+   * driving pull mode against canned /sync responses without a homeserver.
+   */
+  fetch?: typeof globalThis.fetch
 }
 
 export interface DaemonHandle {
@@ -149,6 +157,7 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
   )
 
   let server: ServerType | null = null
+  let syncLoops: SyncLoop[] | undefined
   let stopped = false
   let resolveStopped!: () => void
   const whenStopped = new Promise<void>((r) => {
@@ -159,9 +168,17 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
   let port: number
 
   if (matrix) {
+    const mode = matrix.transport.mode ?? 'appservice'
+    // Pull (client) mode persists a per-agent `since` cursor for offline resume,
+    // so it needs a data dir. Push mode doesn't.
+    if (mode === 'client' && !opts.agentsDir) {
+      throw new Error('matrix client (pull) mode requires a data dir for since-cursor persistence')
+    }
+    const cursors = opts.agentsDir ? makeSyncCursorStore(opts.agentsDir) : undefined
     const client = new MatrixClient({
       homeserver: matrix.transport.homeserver,
       asToken: matrix.transport.as_token,
+      ...(opts.fetch ? { fetch: opts.fetch } : {}),
     })
     const mediaClient = new MediaClient({
       homeserver: matrix.transport.homeserver,
@@ -184,6 +201,16 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
       binding.agentWorkspacePath = isContainerRuntime ? '/workspace' : workspaceDir
       bindings.push(binding)
     }
+    // user_namespace is a regex like `@.*:localhost`; the part after the last
+    // `:` is the homeserver's server_name. Fall back to the homeserver URL's
+    // host if the namespace shape is unexpected.
+    const serverName =
+      matrix.transport.user_namespace.split(':').slice(1).join(':').replace(/\\?\)?$/, '') ||
+      new URL(matrix.transport.homeserver).hostname
+    const asUserId = `@${matrix.transport.sender_localpart}:${serverName}`
+    // Pull mode's loadSince/saveSince are keyed by MXID; the cursor store is
+    // keyed by agent name. Translate via the bindings we just built.
+    const nameByUserId = new Map(bindings.map((b) => [b.userId, b.name]))
     const transport = createMatrixTransport({
       agents: registry,
       approvals,
@@ -191,22 +218,29 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
       bindings,
       hsToken: matrix.transport.hs_token,
       adminUserId: opts.adminUserId,
+      botUserId: asUserId,
       media: mediaClient,
+      mode,
+      loadSince: (uid) => {
+        const name = nameByUserId.get(uid)
+        return name && cursors ? cursors.loadSince(name) : null
+      },
+      saveSince: (uid, since) => {
+        const name = nameByUserId.get(uid)
+        if (name && cursors) cursors.saveSince(name, since)
+      },
     })
-    const requestedPort = matrix.transport.port ?? 9000
-    // Bind 0.0.0.0 explicitly — @hono/node-server defaults to IPv6-only on
-    // macOS, which Docker's NAT bridge can't reach when Tuwunel pushes AS
-    // events back to host.docker.internal:<port>.
-    server = serve({ fetch: transport.app.fetch, port: requestedPort, hostname: '0.0.0.0' })
-    port = await listenAsync(server)
-
-    // user_namespace is a regex like `@.*:localhost`; the part after the last
-    // `:` is the homeserver's server_name. Fall back to the homeserver URL's
-    // host if the namespace shape is unexpected.
-    const serverName =
-      matrix.transport.user_namespace.split(':').slice(1).join(':').replace(/\\?\)?$/, '') ||
-      new URL(matrix.transport.homeserver).hostname
-    const asUserId = `@${matrix.transport.sender_localpart}:${serverName}`
+    if (shouldBindHttpListener(mode)) {
+      const requestedPort = matrix.transport.port ?? 9000
+      // Bind 0.0.0.0 explicitly — @hono/node-server defaults to IPv6-only on
+      // macOS, which Docker's NAT bridge can't reach when Tuwunel pushes AS
+      // events back to host.docker.internal:<port>.
+      server = serve({ fetch: transport.app.fetch, port: requestedPort, hostname: '0.0.0.0' })
+      port = await listenAsync(server)
+    } else {
+      // Pull (client) mode runs outbound /sync loops; no inbound listener.
+      port = 0
+    }
     const spaceLocalpart = matrix.transport.space ?? 'dev'
     const adminUserIds = opts.adminUserId ? [opts.adminUserId] : []
     let spaceRoomId: string | undefined
@@ -233,6 +267,14 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
     // m.space.child while joining it.
     await transport.bootstrap({ spaceRoomId, asUserId, adminUserIds })
 
+    // Pull mode: start the outbound /sync loops after bootstrap so the rooms
+    // each agent syncs already exist. Loops long-poll until stop().
+    syncLoops = transport.syncLoops
+    if (syncLoops?.length) {
+      for (const loop of syncLoops) void loop.run()
+      console.log(`[matrix] pull mode: ${syncLoops.length} sync loop(s) running`)
+    }
+
     if (spaceRoomId) {
       try {
         const generalRoomId = await ensureDefaultChannel({
@@ -253,7 +295,7 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
           asUserId,
           getAgents: () => bindings,
         })
-        console.log(`[matrix] published eco.zoon.workforce (${bindings.length} agents)`)
+        console.log(`[matrix] published dev.zooid.workforce (${bindings.length} agents)`)
         void publisher
       } catch (err) {
         console.warn('[matrix] workforce roster publication failed:', err)
@@ -272,6 +314,11 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
   const stop = async (): Promise<void> => {
     if (stopped) return whenStopped
     stopped = true
+    try {
+      if (syncLoops) for (const loop of syncLoops) loop.stop()
+    } catch {
+      // swallow
+    }
     try {
       if (server) await closeAsync(server)
     } catch {

package/src/daemon/sync-cursors.test.ts

@@ -0,0 +1,38 @@
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { makeSyncCursorStore } from './sync-cursors.js'
+
+let agentsDir: string
+beforeEach(() => {
+  agentsDir = mkdtempSync(join(tmpdir(), 'zooid-agents-'))
+})
+afterEach(() => rmSync(agentsDir, { recursive: true, force: true }))
+
+describe('makeSyncCursorStore', () => {
+  it('returns null before any save (cold start)', () => {
+    const store = makeSyncCursorStore(agentsDir)
+    expect(store.loadSince('docs')).toBeNull()
+  })
+
+  it('round-trips a since cursor per agent name', () => {
+    const store = makeSyncCursorStore(agentsDir)
+    store.saveSince('docs', 's42')
+    store.saveSince('triage', 's7')
+    expect(store.loadSince('docs')).toBe('s42')
+    expect(store.loadSince('triage')).toBe('s7')
+  })
+
+  it('persists across store instances (simulates daemon restart)', () => {
+    makeSyncCursorStore(agentsDir).saveSince('docs', 's99')
+    expect(makeSyncCursorStore(agentsDir).loadSince('docs')).toBe('s99')
+  })
+
+  it('writes sync-since beside sessions.json under <agentsDir>/<agentName>/', () => {
+    makeSyncCursorStore(agentsDir).saveSince('docs', 's1')
+    const path = join(agentsDir, 'docs', 'sync-since')
+    expect(existsSync(path)).toBe(true)
+    expect(readFileSync(path, 'utf8')).toBe('s1')
+  })
+})

package/src/daemon/sync-cursors.ts

@@ -0,0 +1,31 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+export interface SyncCursorStore {
+  loadSince(agentName: string): string | null
+  saveSince(agentName: string, since: string): void
+}
+
+/**
+ * File-backed `since` cursor store: `<agentsDir>/<agentName>/sync-since`, next
+ * to the `(threadId → sessionId)` `sessions.json` buildAcpRegistry writes. Same
+ * per-agent durable-state root, so an agent's restart-surviving state lives in
+ * one folder. Agent names are validated kebab-case keys (ZOD063 isValidAgentKey),
+ * so they're safe path segments — no hashing needed.
+ */
+export function makeSyncCursorStore(agentsDir: string): SyncCursorStore {
+  const fileFor = (agentName: string): string => join(agentsDir, agentName, 'sync-since')
+  return {
+    loadSince(agentName) {
+      try {
+        return readFileSync(fileFor(agentName), 'utf8').trim() || null
+      } catch {
+        return null
+      }
+    },
+    saveSince(agentName, since) {
+      mkdirSync(join(agentsDir, agentName), { recursive: true })
+      writeFileSync(fileFor(agentName), since, 'utf8')
+    },
+  }
+}

package/src/web/fetch.integration.test.ts

@@ -10,26 +10,26 @@ import { makeBundleTgz } from './test-helpers.js'
 let server: Server
 let base = ''
 const { tgz, integrity } = makeBundleTgz({
-  'package/package.json': '{"name":"@zooid/zoon-web"}',
+  'package/package.json': '{"name":"@zooid/web"}',
   'package/dist/index.html': '<html>integration</html>',
 })
 
 beforeAll(async () => {
   server = createServer((req, res) => {
-    if (req.url === '/@zooid/zoon-web') {
+    if (req.url === '/@zooid/web') {
       res.setHeader('content-type', 'application/json')
       res.end(
         JSON.stringify({
           versions: {
             '0.1.0': {
-              dist: { tarball: `${base}/@zooid/zoon-web/-/zoon-web-0.1.0.tgz`, integrity },
+              dist: { tarball: `${base}/@zooid/web/-/web-0.1.0.tgz`, integrity },
             },
           },
         }),
       )
       return
     }
-    if (req.url === '/@zooid/zoon-web/-/zoon-web-0.1.0.tgz') {
+    if (req.url === '/@zooid/web/-/web-0.1.0.tgz') {
       res.setHeader('content-type', 'application/octet-stream')
       res.end(tgz)
       return

package/src/web/fetch.test.ts

@@ -9,14 +9,14 @@ function registryFetch(opts: { tgz: Buffer; integrity: string; version?: string
   const version = opts.version ?? '0.1.0'
   return vi.fn(async (url: string | URL) => {
     const u = String(url)
-    if (u === 'https://registry.npmjs.org/@zooid/zoon-web') {
+    if (u === 'https://registry.npmjs.org/@zooid/web') {
       return new Response(
         JSON.stringify({
           'dist-tags': { latest: version },
           versions: {
             [version]: {
               dist: {
-                tarball: `https://registry.npmjs.org/@zooid/zoon-web/-/zoon-web-${version}.tgz`,
+                tarball: `https://registry.npmjs.org/@zooid/web/-/web-${version}.tgz`,
                 integrity: opts.integrity,
               },
             },
@@ -25,7 +25,7 @@ function registryFetch(opts: { tgz: Buffer; integrity: string; version?: string
         { status: 200 },
       )
     }
-    if (u.endsWith(`/zoon-web-${version}.tgz`)) {
+    if (u.endsWith(`/web-${version}.tgz`)) {
       return new Response(new Uint8Array(opts.tgz), { status: 200 })
     }
     return new Response('not found', { status: 404 })
@@ -86,7 +86,7 @@ describe('fetchWebBundle', () => {
       const { tgz, integrity } = makeBundleTgz()
       const f = registryFetch({ tgz, integrity, version: '0.0.9' })
       await expect(fetchWebBundle({ version: '0.1.0', cacheDir, fetch: f })).rejects.toThrow(
-        /@zooid\/zoon-web@0\.1\.0/,
+        /@zooid\/web@0\.1\.0/,
       )
     } finally {
       teardown()

package/src/web/fetch.ts

@@ -3,7 +3,7 @@ import { join } from 'node:path'
 import { createHash, randomUUID } from 'node:crypto'
 import * as tar from 'tar'
 
-const PKG = '@zooid/zoon-web'
+const PKG = '@zooid/web'
 const DEFAULT_REGISTRY = 'https://registry.npmjs.org'
 
 export interface FetchWebBundleOptions {
@@ -14,7 +14,7 @@ export interface FetchWebBundleOptions {
 }
 
 /**
- * Ensure <cacheDir>/<version> holds the extracted dist/ of @zooid/zoon-web.
+ * Ensure <cacheDir>/<version> holds the extracted dist/ of @zooid/web.
  * Atomic: extracts into a temp dir and renames, so a crash never leaves a
  * half-populated version dir. A populated version dir (index.html present)
  * is the completion marker.

package/src/web/pin.test.ts

@@ -9,10 +9,10 @@ beforeEach(() => (dir = mkdtempSync(join(tmpdir(), 'zooid-pin-'))))
 afterEach(() => rmSync(dir, { recursive: true, force: true }))
 
 describe('readZoonWebPin', () => {
-  it('reads zooid.zoonWebVersion from the cli package.json', () => {
+  it('reads zooid.webVersion from the cli package.json', () => {
     writeFileSync(
       join(dir, 'package.json'),
-      JSON.stringify({ name: 'zooid', zooid: { zoonWebVersion: '0.1.0' } }),
+      JSON.stringify({ name: 'zooid', zooid: { webVersion: '0.1.0' } }),
     )
     expect(readZoonWebPin(dir)).toBe('0.1.0')
   })

package/src/web/pin.ts

@@ -4,9 +4,9 @@ import { join } from 'node:path'
 export function readZoonWebPin(cliRoot: string): string | undefined {
   try {
     const pkg = JSON.parse(readFileSync(join(cliRoot, 'package.json'), 'utf8')) as {
-      zooid?: { zoonWebVersion?: string }
+      zooid?: { webVersion?: string }
     }
-    return pkg.zooid?.zoonWebVersion
+    return pkg.zooid?.webVersion
   } catch {
     return undefined
   }

package/src/web/resolve.test.ts

@@ -16,10 +16,10 @@ afterEach(() => {
 function makeSibling(rootDir: string): { cliRoot: string; webDist: string } {
   const cliRoot = join(rootDir, 'zooid', 'packages', 'cli')
   mkdirSync(cliRoot, { recursive: true })
-  const webPkg = join(rootDir, 'zoon', 'packages', 'web')
+  const webPkg = join(rootDir, 'zooid-clients', 'packages', 'web')
   const webDist = join(webPkg, 'dist')
   mkdirSync(webDist, { recursive: true })
-  writeFileSync(join(webPkg, 'package.json'), '{"name":"@zooid/zoon-web"}')
+  writeFileSync(join(webPkg, 'package.json'), '{"name":"@zooid/web"}')
   writeFileSync(join(webDist, 'index.html'), '<html/>')
   return { cliRoot, webDist }
 }
@@ -62,14 +62,14 @@ describe('ensureWebRoot', () => {
     mkdirSync(cliRoot, { recursive: true })
     await expect(
       ensureWebRoot({ cliRoot, cacheDir: join(root, 'cache'), version: undefined, fetchBundle: vi.fn() }),
-    ).rejects.toThrow(/zoonWebVersion/)
+    ).rejects.toThrow(/webVersion/)
   })
 })
 
 describe('webSourcePackage', () => {
-  it('returns the source package dir when sibling zoon/packages/web exists', () => {
+  it('returns the source package dir when sibling zooid-clients/packages/web exists', () => {
     const { cliRoot } = makeSibling(root)
-    expect(webSourcePackage(cliRoot)).toBe(join(root, 'zoon', 'packages', 'web'))
+    expect(webSourcePackage(cliRoot)).toBe(join(root, 'zooid-clients', 'packages', 'web'))
   })
 
   it('returns null outside the monorepo', () => {

package/src/web/resolve.ts

@@ -23,21 +23,21 @@ export async function ensureWebRoot(opts: EnsureWebRootOptions): Promise<string>
 
   if (!opts.version) {
     throw new Error(
-      `No @zooid/zoon-web version pin (zooid.zoonWebVersion) in the cli package.json ` +
+      `No @zooid/web version pin (zooid.webVersion) in the cli package.json ` +
         `and no monorepo sibling build found.\n` +
         `Set ${ENV_OVERRIDE} to a built dist, or run from the monorepo.`,
     )
   }
-  opts.onProgress?.(`Fetching @zooid/zoon-web ${opts.version}…`)
+  opts.onProgress?.(`Fetching @zooid/web ${opts.version}…`)
   const fetchBundleFn = opts.fetchBundle ?? fetchWebBundle
   return fetchBundleFn({ version: opts.version, cacheDir: opts.cacheDir })
 }
 
-// Returns the path to the in-tree @zooid/zoon-web package (zoon/packages/web) if the
+// Returns the path to the in-tree @zooid/web package (zooid-clients/packages/web) if the
 // CLI is running from the monorepo source. Returns null when running from an
-// installed package (no sibling zoon/ tree).
+// installed package (no sibling zooid-clients/ tree).
 export function webSourcePackage(cliRoot: string): string | null {
   const workspaceRoot = dirname(dirname(dirname(cliRoot)))
-  const candidate = join(workspaceRoot, 'zoon', 'packages', 'web')
+  const candidate = join(workspaceRoot, 'zooid-clients', 'packages', 'web')
   return existsSync(join(candidate, 'package.json')) ? candidate : null
 }

package/src/web/test-helpers.ts

@@ -6,7 +6,7 @@ import * as tar from 'tar'
 
 export function makeBundleTgz(
   files: Record<string, string> = {
-    'package/package.json': '{"name":"@zooid/zoon-web"}',
+    'package/package.json': '{"name":"@zooid/web"}',
     'package/dist/index.html': '<html>zoon</html>',
     'package/dist/assets/app.js': '// app',
   },