zooid 0.8.0 → 0.9.1

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   buildAcpRegistry
-} from "./chunk-R6EDLH23.js";
+} from "./chunk-PDSJJWQW.js";
 export {
   buildAcpRegistry
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zooid",
-  "version": "0.8.0",
-  "description": "Open-source tool for defining and running AI agents alongside you and your team. Any model, any CLI.",
+  "version": "0.9.1",
+  "description": "An open-source, self-hostable chat app for collaborating with AI agents alongside your team. Any model, any CLI.",
   "type": "module",
   "license": "MIT",
   "private": false,
@@ -25,7 +25,7 @@
     "access": "public"
   },
   "zooid": {
-    "zoonWebVersion": "0.1.0"
+    "webVersion": "0.8.0"
   },
   "engines": {
     "node": ">=22"
@@ -41,13 +41,13 @@
     "sanitize-html": "^2.17.4",
     "tar": "^7.5.16",
     "yaml": "^2.5.0",
-    "@zooid/context-mcp": "^0.8.0",
-    "@zooid/core": "^0.8.0",
-    "@zooid/acp-client": "^0.8.0",
-    "@zooid/transport-http": "^0.8.0",
-    "@zooid/transport-matrix": "^0.8.0",
-    "@zooid/runtime-docker": "^0.8.0",
-    "@zooid/runtime-local": "^0.8.0"
+    "@zooid/acp-client": "^0.9.1",
+    "@zooid/context-mcp": "^0.9.1",
+    "@zooid/core": "^0.9.1",
+    "@zooid/runtime-docker": "^0.9.1",
+    "@zooid/runtime-local": "^0.9.1",
+    "@zooid/transport-http": "^0.9.1",
+    "@zooid/transport-matrix": "^0.9.1"
   },
   "devDependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",

package/src/bin.ts

@@ -33,7 +33,7 @@ cli
   .option('--admin-password <pw>', 'Admin password', { default: 'admin' })
   .option(
     '--watch-web [path]',
-    'Run vite build --watch on @zooid/zoon-web. Path defaults to sibling ../zoon/packages/web.',
+    'Run vite build --watch on @zooid/web. Path defaults to sibling ../zooid-clients/packages/web.',
   )
   .action(async (flags) => {
     await runDev({

package/src/bootstrap/configs.ts

@@ -1,5 +1,7 @@
+import { join } from 'node:path'
 import { mkdirSync, writeFileSync } from 'node:fs'
 import { renderRegistration } from '@zooid/transport-matrix'
+import { deriveRegistrationUrl } from './registration-url.js'
 import type { Paths } from './paths.js'
 
 export interface TuwunelTomlOpts {
@@ -35,6 +37,12 @@ export interface BootstrapConfigsOpts {
   hsToken: string
   senderLocalpart: string
   userNamespace: string
+  /** Workstation id. When set: registration id = workstation, exclusive namespace, url derived from port/advertise_url. */
+  workstation?: string
+  /** AS HTTP listener port. Used to derive the registration url when workstation is set. */
+  port?: number
+  /** Explicit registration url override. Mutually exclusive with port. */
+  advertiseUrl?: string
 }
 
 export function writeBootstrapConfigs(opts: BootstrapConfigsOpts): void {
@@ -45,9 +53,16 @@ export function writeBootstrapConfigs(opts: BootstrapConfigsOpts): void {
 
   writeFileSync(paths.tuwunelTomlPath, renderTuwunelToml({ serverName }))
 
+  const id = opts.workstation ?? 'zooid'
+  const url = opts.workstation
+    ? deriveRegistrationUrl({ port: opts.port ?? 9099, advertise_url: opts.advertiseUrl })
+    : `http://host.docker.internal:9099`
+  const exclusive = !!opts.workstation
+  const registrationPath = join(paths.registrationsDir, `${id}.yaml`)
+
   const yaml = renderRegistration({
-    id: 'zooid',
-    url: `http://host.docker.internal:9099`,
+    id,
+    url,
     homeserver: `http://localhost:${TUWUNEL_INTERNAL_PORT}`,
     asToken,
     hsToken,
@@ -56,9 +71,7 @@ export function writeBootstrapConfigs(opts: BootstrapConfigsOpts): void {
     // BotPool.bootstrap creates `#alias:<server>` rooms when missing — the
     // AS needs an aliases namespace to legally claim them.
     aliasNamespace: `#.*:${serverName}`,
-    // zooid dev shares @.*:<server_name> between bots and the predefined
-    // admin human, so the AS cannot claim the namespace exclusively.
-    exclusive: false,
+    exclusive,
   })
-  writeFileSync(paths.appserviceYamlPath, yaml)
+  writeFileSync(registrationPath, yaml)
 }

package/src/bootstrap/derive.ts

@@ -6,7 +6,8 @@ export interface HomeserverShape {
   serverName: string
 }
 
-const NAMESPACE_RE = /^@\.\*:([A-Za-z0-9.-]+)$/
+// Matches @.*:server (flat) or @<workstation>\..*:server (workstation-scoped exclusive namespace)
+const NAMESPACE_RE = /^@(?:\.\*|[a-z0-9-]+\\\.\.\*):([A-Za-z0-9.-]+)$/
 
 export function deriveHomeserverShape(
   matrix: MatrixTransportConfig,
@@ -23,7 +24,7 @@ export function deriveHomeserverShape(
   const m = NAMESPACE_RE.exec(matrix.user_namespace)
   if (!m) {
     throw new Error(
-      `user_namespace ${matrix.user_namespace!}: expected the simple form '@.*:<server_name>'`,
+      `user_namespace ${matrix.user_namespace!}: expected '@.*:<server_name>' or '@<workstation>\\\..*:<server_name>'`,
     )
   }
   const serverName = m[1]!

package/src/bootstrap/identity-bootstrap.integration.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { parse } from 'yaml'
+import { loadZooidConfig, findMatrixTransport } from '@zooid/core'
+import { writeBootstrapConfigs } from './configs.js'
+import { resolvePaths } from './paths.js'
+
+const YAML = `
+runtime: podman
+workstation: laptop
+transports:
+  matrix:
+    homeserver: http://localhost:8448
+    as_token: as-x
+    hs_token: hs-x
+    port: 9099
+agents:
+  docs: { acp: { preset: opencode }, matrix: { rooms: ['#docs'] } }
+`
+
+describe('bootstrap emits a workstation-scoped registration', () => {
+  let dir: string
+  afterEach(() => dir && rmSync(dir, { recursive: true, force: true }))
+
+  it('config → registration round-trip is workstation-consistent', () => {
+    dir = mkdtempSync(join(tmpdir(), 'zod063-'))
+    const dataDir = join(dir, 'data', 'matrix')
+    const paths = resolvePaths(dataDir)
+    const cfg = loadZooidConfig(YAML)
+    const m = findMatrixTransport(cfg)!.transport
+
+    writeBootstrapConfigs({
+      paths,
+      serverName: new URL(m.homeserver).hostname,
+      asToken: 'as-x',
+      hsToken: 'hs-x',
+      senderLocalpart: m.sender_localpart,
+      userNamespace: m.user_namespace,
+      workstation: m.workstation,
+      port: m.port,
+    })
+
+    const regPath = join(dataDir, 'config', 'registrations', 'laptop.yaml')
+    const reg = parse(readFileSync(regPath, 'utf8'))
+    expect(reg.id).toBe('laptop')
+    expect(reg.sender_localpart).toBe('laptop')
+    expect(reg.namespaces.users[0]).toEqual({ exclusive: true, regex: '@laptop\\..*:localhost' })
+    // co-located: url advertises the daemon's bind port back to the homeserver
+    expect(reg.url).toBe('http://host.docker.internal:9099')
+  })
+})

package/src/bootstrap/registration-url.test.ts

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest'
+import { deriveRegistrationUrl } from './registration-url.js'
+
+describe('deriveRegistrationUrl', () => {
+  it('port → co-located host.docker.internal shorthand', () => {
+    expect(deriveRegistrationUrl({ port: 9099 })).toBe('http://host.docker.internal:9099')
+  })
+  it('advertise_url → verbatim', () => {
+    expect(deriveRegistrationUrl({ advertise_url: 'http://10.0.1.5:9099' })).toBe('http://10.0.1.5:9099')
+  })
+  it('throws if both are present (caller should have rejected earlier, defense-in-depth)', () => {
+    expect(() => deriveRegistrationUrl({ port: 9099, advertise_url: 'http://x:1' })).toThrow()
+  })
+})

package/src/bootstrap/registration-url.ts

@@ -0,0 +1,7 @@
+export function deriveRegistrationUrl(opts: { port?: number; advertise_url?: string }): string {
+  if (opts.port != null && opts.advertise_url != null)
+    throw new Error("registration url: 'port' and 'advertise_url' are mutually exclusive")
+  if (opts.advertise_url != null) return opts.advertise_url
+  if (opts.port != null) return `http://host.docker.internal:${opts.port}`
+  throw new Error('registration url: need port or advertise_url')
+}

package/src/commands/dev.ts

@@ -67,8 +67,8 @@ export interface DevFlags {
   adminPassword: string
   installSignalHandlers?: boolean
   foreground?: boolean
-  // Run `vite build --watch` against a @zooid/zoon-web package and serve its dist.
-  // true = auto-detect (sibling ../zoon/packages/web or in-monorepo); string = explicit path.
+  // Run `vite build --watch` against a @zooid/web package and serve its dist.
+  // true = auto-detect (sibling ../zooid-clients/packages/web or in-monorepo); string = explicit path.
   watchWeb?: string | boolean
 }
 
@@ -217,17 +217,17 @@ export async function runDev(flags: DevFlags): Promise<DevHandle> {
       ...(flags.watchWeb
         ? [
             {
-              title: 'Start @zooid/zoon-web watcher (vite build --watch)',
+              title: 'Start @zooid/web watcher (vite build --watch)',
               task: async (): Promise<void> => {
                 const pkgDir =
                   typeof flags.watchWeb === 'string'
                     ? resolve(flags.watchWeb)
                     : webSourcePackage(CLI_ROOT)
                 if (!pkgDir) {
-                  const defaultPath = dirname(dirname(dirname(CLI_ROOT))) + '/zoon/packages/web'
+                  const defaultPath = dirname(dirname(dirname(CLI_ROOT))) + '/zooid-clients/packages/web'
                   throw new Error(
-                    `--watch-web: @zooid/zoon-web not found at ${defaultPath}.\n` +
-                      `Pass an explicit path: --watch-web=/path/to/zoon/packages/web`,
+                    `--watch-web: @zooid/web not found at ${defaultPath}.\n` +
+                      `Pass an explicit path: --watch-web=/path/to/zooid-clients/packages/web`,
                   )
                 }
                 ctx.webWatch = await startWebWatch({ webPackageDir: pkgDir })
@@ -236,7 +236,7 @@ export async function runDev(flags: DevFlags): Promise<DevHandle> {
           ]
         : []),
       {
-        title: `Serve @zooid/zoon-web on http://localhost:${flags.uiPort}`,
+        title: `Serve @zooid/web on http://localhost:${flags.uiPort}`,
         task: async (_, t) => {
           const webRoot =
             ctx.webWatch?.distPath ??
@@ -300,11 +300,11 @@ export async function runDev(flags: DevFlags): Promise<DevHandle> {
     [
       '',
       chalk.bold('Tuwunel is up.') + ` ${homeserver}`,
-      chalk.bold('UI:        ') + ` http://localhost:${flags.uiPort}`,
+      chalk.bold('UI:        ') + ` http://localhost:${(ctx.uiServer?.address() as { port?: number } | null)?.port ?? flags.uiPort}`,
       `  ${chalk.cyan('admin user:')} ${flags.adminUser} / ${flags.adminPassword}`,
       `  ${chalk.cyan('data dir:')} ${layout.dataRoot}`,
       ...(ctx.webWatch
-        ? [`  ${chalk.cyan('web watcher:')} live (vite build --watch on @zooid/zoon-web)`]
+        ? [`  ${chalk.cyan('web watcher:')} live (vite build --watch on @zooid/web)`]
         : []),
       '',
       chalk.dim('Press Ctrl-C to stop.'),

package/src/commands/init/generators.test.ts

@@ -9,24 +9,34 @@ import {
 } from './generators.js'
 
 describe('generateZooidYaml', () => {
-  it('produces the short post-ZOD048 shape for claude + model', () => {
-    const out = generateZooidYaml({
-      preset: 'claude',
-      model: 'claude-sonnet-4-6',
-    })
+  it('produces the short shape for claude with NO model (harness default)', () => {
+    const out = generateZooidYaml({ preset: 'claude' })
     expect(out).toContain('runtime: local')
+    expect(out).toContain('workstation: dev')
     expect(out).toContain('homeserver: http://localhost:8448')
     expect(out).toContain('port: 9099')
     expect(out).toContain('zooid-assistant:')
-    expect(out).toContain('preset: claude')
-    expect(out).toContain('model: claude-sonnet-4-6')
+    expect(out).toContain('acp: { preset: claude }')
     expect(out).toContain("display_name: 'Zooid Assistant'")
     expect(out).toContain("rooms: ['#zooid']")
+    expect(out).not.toContain('model:')
     expect(out).not.toContain('user_id:')
     expect(out).not.toContain('workdir:')
     expect(out).not.toContain('transport: matrix')
   })
 
+  it('expands the acp block to carry a model only when one is pinned', () => {
+    const out = generateZooidYaml({ preset: 'claude', model: 'claude-opus-4-8' })
+    expect(out).toContain('preset: claude')
+    expect(out).toContain('model: claude-opus-4-8')
+  })
+
+  it('includes a comment pointing at pull mode for remote/NAT setups', () => {
+    const out = generateZooidYaml({ preset: 'claude' })
+    expect(out).toContain('mode: client')
+    expect(out).toMatch(/pull mode/i)
+  })
+
   it('omits model on the acp block for opencode (model lives in opencode.json)', () => {
     const out = generateZooidYaml({ preset: 'opencode' })
     expect(out).toContain('acp: { preset: opencode }')
@@ -59,22 +69,30 @@ describe('generateClaudeSettings', () => {
 })
 
 describe('generateOpencodeJson', () => {
-  it('produces opencode-go/<model> with the OPENCODE_API_KEY env reference', () => {
+  it('omits model by default (opencode picks its own) but keeps provider + apiKey', () => {
     const out = generateOpencodeJson({
       provider: 'opencode-go',
-      model: 'kimi-k2.6',
       apiKeyEnvVar: 'OPENCODE_API_KEY',
     })
     const parsed = JSON.parse(out)
-    expect(parsed.model).toBe('opencode-go/kimi-k2.6')
+    expect(parsed).not.toHaveProperty('model')
     expect(parsed.provider['opencode-go'].options.apiKey).toBe('{env:OPENCODE_API_KEY}')
     expect(parsed.permission.webfetch).toBe('allow')
   })
 
-  it('produces a TODO stub for the custom provider', () => {
+  it('writes provider/model only when a model is pinned', () => {
+    const out = generateOpencodeJson({
+      provider: 'opencode-go',
+      model: 'kimi-k2.6',
+      apiKeyEnvVar: 'OPENCODE_API_KEY',
+    })
+    expect(JSON.parse(out).model).toBe('opencode-go/kimi-k2.6')
+  })
+
+  it('produces a model-less TODO stub for the custom provider', () => {
     const out = generateOpencodeJson({ provider: 'custom' })
     const parsed = JSON.parse(out)
-    expect(parsed.model).toMatch(/TODO/)
+    expect(parsed).not.toHaveProperty('model')
     expect(parsed.provider).toHaveProperty('TODO')
   })
 })

package/src/commands/init/generators.ts

@@ -1,15 +1,27 @@
 export interface ZooidYamlOpts {
   preset: 'claude' | 'codex' | 'opencode'
-  /** Only set for claude / codex; opencode reads its own opencode.json. */
+  /**
+   * Optional model pin. Omitted by default — the harness picks its own current
+   * default. Only set when the user passes `--model` (claude / codex); opencode
+   * reads its own opencode.json.
+   */
   model?: string
 }
 
 export function generateZooidYaml(opts: ZooidYamlOpts): string {
+  // No model by default: the harness chooses. A `--model` pin (claude/codex
+  // only) expands the block to carry it.
   const acpBlock =
-    opts.preset === 'opencode'
-      ? `    acp: { preset: opencode }`
+    opts.preset === 'opencode' || !opts.model
+      ? `    acp: { preset: ${opts.preset} }`
       : `    acp:\n      preset: ${opts.preset}\n      model: ${opts.model}`
   return `runtime: local
+workstation: dev
+
+# This daemon connects in push mode: the homeserver reaches the listener on
+# \`port\` below. To run it against a homeserver it can't open a port to —
+# e.g. on your laptop, behind NAT — switch to pull mode: set \`mode: client\`
+# under transports.matrix and drop \`port\`. Agents are reachable either way.
 
 transports:
   matrix:
@@ -83,7 +95,6 @@ export function generateOpencodeJson(opts: OpencodeJsonOpts): string {
       JSON.stringify(
         {
           $schema: 'https://opencode.ai/config.json',
-          model: 'TODO/your-model',
           provider: { TODO: { options: {} } },
         },
         null,
@@ -91,16 +102,16 @@ export function generateOpencodeJson(opts: OpencodeJsonOpts): string {
       ) + '\n'
     )
   }
-  const cfg = {
-    $schema: 'https://opencode.ai/config.json',
-    model: `${opts.provider}/${opts.model}`,
-    provider: {
-      [opts.provider]: {
-        options: { apiKey: `{env:${opts.apiKeyEnvVar}}` },
-      },
+  // No `model` by default — opencode picks its own default. A `--model` pin
+  // writes the `provider/model` route.
+  const cfg: Record<string, unknown> = { $schema: 'https://opencode.ai/config.json' }
+  if (opts.model) cfg.model = `${opts.provider}/${opts.model}`
+  cfg.provider = {
+    [opts.provider]: {
+      options: { apiKey: `{env:${opts.apiKeyEnvVar}}` },
     },
-    permission: { webfetch: 'allow' as const },
   }
+  cfg.permission = { webfetch: 'allow' as const }
   return JSON.stringify(cfg, null, 2) + '\n'
 }
 

package/src/commands/init/prompts.ts

@@ -1,9 +1,5 @@
 import { select, password } from '@inquirer/prompts'
-import {
-  OPENCODE_PROVIDERS,
-  findOpencodeProvider,
-  findSimplePreset,
-} from './registry.js'
+import { findOpencodeProvider, findSimplePreset } from './registry.js'
 import type { InitOptions } from '../init.js'
 
 export interface PromptInput {
@@ -38,19 +34,10 @@ export async function resolveOptions(flags: PromptInput): Promise<InitOptions> {
   ))
 
   if (preset === 'opencode') {
-    const provider = flags.provider ?? (await ask(
-      () => select({
-        message: 'Which provider?',
-        choices: [
-          ...OPENCODE_PROVIDERS.map((p) => ({
-            name: `${p.label}  (${p.description})`,
-            value: p.id,
-          })),
-          { name: 'custom (write your own opencode.json block)', value: 'custom' },
-        ],
-      }),
-      () => '--provider is required for opencode',
-    ))
+    // The interactive wizard never asks which provider/model — it defaults to
+    // opencode-go (the recommended subscription) and just collects the API key.
+    // Other providers and a pinned model are reachable via --provider / --model.
+    const provider = flags.provider ?? 'opencode-go'
     if (provider === 'custom') {
       return {
         dir: flags.dir,
@@ -62,13 +49,6 @@ export async function resolveOptions(flags: PromptInput): Promise<InitOptions> {
     }
     const meta = findOpencodeProvider(provider)
     if (!meta) throw new Error(`unknown opencode provider: ${provider}`)
-    const model = flags.model ?? (await ask(
-      () => select({
-        message: 'Which model?',
-        choices: meta.models.map((m) => ({ name: m, value: m })),
-      }),
-      () => '--model is required',
-    ))
     const apiKey = flags.apiKey ?? (await ask(
       () => password({ message: `${meta.label} API key:` }),
       () => '--api-key is required',
@@ -77,7 +57,7 @@ export async function resolveOptions(flags: PromptInput): Promise<InitOptions> {
       dir: flags.dir,
       preset,
       provider,
-      model,
+      model: flags.model,
       apiKey,
       force: flags.force,
       overwrite: flags.overwrite,
@@ -96,13 +76,8 @@ export async function resolveOptions(flags: PromptInput): Promise<InitOptions> {
     }),
     () => '--auth is required (subscription | api-key)',
   ))
-  const model = flags.model ?? (await ask(
-    () => select({
-      message: 'Which model?',
-      choices: meta.models.map((m) => ({ name: m, value: m })),
-    }),
-    () => '--model is required',
-  ))
+  // No model prompt — Claude Code / Codex use their own current default.
+  // `--model` pins one for those who want it.
   const apiKey =
     auth === 'api-key'
       ? flags.apiKey ?? (await ask(
@@ -115,7 +90,7 @@ export async function resolveOptions(flags: PromptInput): Promise<InitOptions> {
     dir: flags.dir,
     preset,
     auth,
-    model,
+    model: flags.model,
     apiKey,
     force: flags.force,
     overwrite: flags.overwrite,

package/src/commands/init/registry.test.ts

@@ -7,11 +7,11 @@ import {
 } from './registry.js'
 
 describe('init registry', () => {
-  it('SIMPLE_PRESETS contains claude and codex with non-empty model lists', () => {
+  it('SIMPLE_PRESETS contains claude and codex (no model lists to maintain)', () => {
     const names = SIMPLE_PRESETS.map((p) => p.preset)
     expect(names).toEqual(['claude', 'codex'])
     for (const p of SIMPLE_PRESETS) {
-      expect(p.models.length).toBeGreaterThan(0)
+      expect(p).not.toHaveProperty('models')
       expect(p.apiKeyEnvVar).toMatch(/^[A-Z_]+_API_KEY$/)
       expect(p.credentialDir.length).toBeGreaterThan(0)
     }

package/src/commands/init/registry.ts

@@ -1,6 +1,11 @@
+// Note: no model lists live here. The wizard never asks for a model — every
+// harness (Claude Code, Codex, opencode) picks its own current default, so
+// there's no version list to keep fresh. A specific model is a normal
+// post-init edit (`model:` in zooid.yaml, or `model` in opencode.json), and
+// can be pinned non-interactively via the optional `--model` flag.
+
 export interface SimplePresetMeta {
   preset: 'claude' | 'codex'
-  models: string[]
   subscriptionLabel: string
   apiKeyEnvVar: string
   apiKeyPromptLabel: string
@@ -11,7 +16,6 @@ export interface SimplePresetMeta {
 export const SIMPLE_PRESETS: readonly SimplePresetMeta[] = [
   {
     preset: 'claude',
-    models: ['claude-sonnet-4-6', 'claude-opus-4-7', 'claude-haiku-4-5'],
     subscriptionLabel: 'Claude subscription (Pro / Max / Team / Enterprise)',
     apiKeyEnvVar: 'ANTHROPIC_API_KEY',
     apiKeyPromptLabel: 'Anthropic',
@@ -19,7 +23,6 @@ export const SIMPLE_PRESETS: readonly SimplePresetMeta[] = [
   },
   {
     preset: 'codex',
-    models: ['gpt-5.5'],
     subscriptionLabel: 'ChatGPT subscription (Plus / Pro / Team)',
     apiKeyEnvVar: 'OPENAI_API_KEY',
     apiKeyPromptLabel: 'OpenAI',
@@ -31,37 +34,35 @@ export interface OpencodeProviderMeta {
   id: string
   label: string
   description: string
-  models: string[]
   apiKeyEnvVar: string
 }
 
+// Providers are an opencode routing/auth concern, reachable via the optional
+// `--provider` flag. The interactive wizard defaults to `opencode-go` (first
+// entry) and only asks for the API key.
 export const OPENCODE_PROVIDERS: readonly OpencodeProviderMeta[] = [
   {
     id: 'opencode-go',
     label: 'opencode-go',
     description: '$10/mo subscription — Kimi, GLM, MiniMax',
-    models: ['kimi-k2.6', 'kimi-k2.5', 'glm-5.1', 'glm-5', 'minimax-m2.7'],
     apiKeyEnvVar: 'OPENCODE_API_KEY',
   },
   {
     id: 'opencode',
     label: 'opencode (Zen)',
     description: 'free tier — curated models',
-    models: ['kimi-k2.5-free', 'glm-4.7-free', 'minimax-m2.1-free'],
     apiKeyEnvVar: 'OPENCODE_API_KEY',
   },
   {
     id: 'anthropic',
     label: 'Anthropic',
     description: 'Claude via direct Anthropic API',
-    models: ['claude-sonnet-4-6', 'claude-opus-4-7', 'claude-haiku-4-5'],
     apiKeyEnvVar: 'ANTHROPIC_API_KEY',
   },
   {
     id: 'openrouter',
     label: 'OpenRouter',
     description: 'many providers via OpenRouter',
-    models: ['anthropic/claude-sonnet-4-6', 'zhipuai/glm-5', 'moonshot/kimi-k2.6'],
     apiKeyEnvVar: 'OPENROUTER_API_KEY',
   },
 ]

package/src/commands/init/scaffold-roundtrip.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { loadZooidConfig, findMatrixTransport } from '@zooid/core'
+import { generateZooidYaml } from './generators.js'
+
+describe('zooid init scaffold round-trips into an in-namespace agent MXID', () => {
+  // The scaffold declares no explicit tokens; loadZooidConfig infers them from
+  // the environment (the real daemon supplies them — `zooid dev` generates them).
+  beforeEach(() => {
+    process.env.MATRIX_AS_TOKEN = 'as-test'
+    process.env.MATRIX_HS_TOKEN = 'hs-test'
+  })
+  afterEach(() => {
+    delete process.env.MATRIX_AS_TOKEN
+    delete process.env.MATRIX_HS_TOKEN
+  })
+
+  it('the generated workstation scaffold parses to @dev.zooid-assistant inside the exclusive namespace', () => {
+    const yaml = generateZooidYaml({ preset: 'claude' })
+    const config = loadZooidConfig(yaml)
+
+    // Workstation drove the registration namespace...
+    const tx = findMatrixTransport(config)!.transport
+    expect(config.workstation).toBe('dev')
+    expect(tx.sender_localpart).toBe('dev')
+    expect(tx.user_namespace).toBe('@dev\\..*:localhost')
+
+    // ...and the agent MXID was derived to sit inside it (no hand-written user_id).
+    const mxid = config.agents['zooid-assistant']!.matrix!.user_id
+    expect(mxid).toBe('@dev.zooid-assistant:localhost')
+    expect(new RegExp(`^${tx.user_namespace}$`).test(mxid)).toBe(true)
+  })
+
+  it('the opencode scaffold derives the same way (preset has no model)', () => {
+    const yaml = generateZooidYaml({ preset: 'opencode' })
+    const config = loadZooidConfig(yaml)
+    expect(config.agents['zooid-assistant']!.matrix!.user_id).toBe('@dev.zooid-assistant:localhost')
+  })
+})