npm - zooid - Versions diffs - 0.7.0 → 0.7.1 - Mend

zooid 0.7.0 → 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/dist/bin.js +106 -12
package/dist/bin.js.map +1 -1
package/dist/{chunk-N5POSZX5.js → chunk-SUPTPSN3.js} +629 -195
package/dist/chunk-SUPTPSN3.js.map +1 -0
package/dist/index.d.ts +27 -3
package/dist/index.js +1 -1
package/dist/web/assets/index-C2MAIew3.css +1 -0
package/dist/web/assets/{index-JZMMlqDP.js → index-CqfWXqvO.js} +1 -1
package/dist/web/assets/{index-BT_v3DKu.js → index-Cz5fEZBc.js} +51 -51
package/dist/web/assets/{reaction-picker-emoji-Kh7emgFa.js → reaction-picker-emoji-cME0vOsX.js} +1 -1
package/dist/web/index.html +2 -2
package/package.json +8 -7
package/src/bin.ts +5 -2
package/src/build-registry.ts +211 -10
package/src/build-registry.zod044.test.ts +261 -0
package/src/commands/dev.ts +15 -7
package/src/commands/init/generators.ts +5 -0
package/src/commands/status.ts +7 -2
package/src/daemon/start-daemon.ts +28 -1
package/src/prepull-images.test.ts +149 -0
package/src/prepull-images.ts +100 -0
package/dist/chunk-N5POSZX5.js.map +0 -1
package/dist/web/assets/index-DJTghnF-.css +0 -1

package/dist/web/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <title>Zoon</title>
-    <script type="module" crossorigin src="/assets/index-BT_v3DKu.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DJTghnF-.css">
+    <script type="module" crossorigin src="/assets/index-Cz5fEZBc.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-C2MAIew3.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "zooid",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Open-source tool for defining and running AI agents alongside you and your team. Any model, any CLI.",
   "type": "module",
   "license": "MIT",
@@ -37,12 +37,13 @@
     "marked": "^18.0.4",
     "sanitize-html": "^2.17.4",
     "yaml": "^2.5.0",
-    "@zooid/runtime-docker": "^0.7.0",
-    "@zooid/core": "^0.7.0",
-    "@zooid/runtime-local": "^0.7.0",
-    "@zooid/transport-matrix": "^0.7.0",
-    "@zooid/context-mcp": "^0.7.0",
-    "@zooid/transport-http": "^0.7.0"
+    "@zooid/acp-client": "^0.7.1",
+    "@zooid/context-mcp": "^0.7.1",
+    "@zooid/core": "^0.7.1",
+    "@zooid/runtime-docker": "^0.7.1",
+    "@zooid/runtime-local": "^0.7.1",
+    "@zooid/transport-http": "^0.7.1",
+    "@zooid/transport-matrix": "^0.7.1"
   },
   "devDependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",

package/src/bin.ts CHANGED Viewed

@@ -31,7 +31,10 @@ cli
   .option('--ui-port <n>', 'UI HTTP port', { default: 5173 })
   .option('--admin-user <name>', 'Admin username', { default: 'admin' })
   .option('--admin-password <pw>', 'Admin password', { default: 'admin' })
-  .option('--watch-web', 'Run vite build --watch on @zoon/web (monorepo source only)')
+  .option(
+    '--watch-web [path]',
+    'Run vite build --watch on @zoon/web. Path defaults to sibling ../zoon/packages/web.',
+  )
   .action(async (flags) => {
     await runDev({
       dataDir: flags.data,
@@ -39,7 +42,7 @@ cli
       uiPort: Number(flags.uiPort),
       adminUser: flags.adminUser,
       adminPassword: flags.adminPassword,
-      watchWeb: Boolean(flags.watchWeb),
+      watchWeb: flags.watchWeb as string | boolean | undefined,
     })
   })

package/src/build-registry.ts CHANGED Viewed

@@ -1,16 +1,21 @@
+import { isAbsolute, resolve as pathResolve } from 'node:path'
 import { LocalAcpRuntime } from '@zooid/runtime-local'
 import { DockerAcpRuntime } from '@zooid/runtime-docker'
 import {
   AcpAgentRegistry,
+  type AcpMount,
   type AcpRuntime,
+  type AgentConfig,
   type ApprovalCorrelator,
   type ContextSpawnFactory,
+  type MountConfig,
   type TapEvent,
   type ZooidConfig,
   type TransportContextProvider,
 } from '@zooid/core'
 import { MatrixClient, MatrixContextProvider } from '@zooid/transport-matrix'
 import { SpawnRegistry, buildContextServerSpec } from '@zooid/context-mcp'
+import { PRESETS, type PresetMount, type PresetName } from '@zooid/acp-client'
 export interface BuildAcpRegistryOptions {
   /** Override the runtime selection (tests). */
@@ -34,6 +39,159 @@ export interface BuildAcpRegistryOptions {
   contextSpawnRegistry?: SpawnRegistry
   /** Path to the daemon's context Unix socket. Passed to the MCP server bin. */
   daemonSockPath?: string
+  /**
+   * Directory containing zooid.yaml. Required when any agent uses the
+   * workspace auto-mount (the default under `runtime: docker | podman`):
+   * relative `agent.workdir` paths are resolved against this dir.
+   */
+  configDir?: string
+  /**
+   * Daemon data root. Each agent's preset mounts target
+   * `<dataDir>/agents/<agentName>` on the host.
+   */
+  dataDir?: string
+  /**
+   * Daemon user's `$HOME`. Sourced by the v1 preset `home` / `data` /
+   * `config` mounts. Tests inject a stub; production threads
+   * `process.env.HOME` from `start-daemon`.
+   */
+  daemonHome?: string
+  /**
+   * Sink for the per-agent "resolved image + mounts" startup log lines.
+   * Defaults to `console.log`. Tests pass a capture array.
+   */
+  log?: (line: string) => void
+}
+type ImageProvenance = 'agent' | 'workforce' | `preset:${PresetName}` | 'unresolved'
+interface ResolvedImage {
+  image: string | undefined
+  source: ImageProvenance
+}
+const CONTAINER_WORKDIR = '/workspace'
+function presetOf(agent: AgentConfig): PresetName | undefined {
+  const spec = agent.acp as { preset?: string } | undefined
+  if (spec?.preset && spec.preset in PRESETS) return spec.preset as PresetName
+  return undefined
+}
+function resolveAgentImage(
+  agent: AgentConfig,
+  cfg: ZooidConfig,
+): ResolvedImage {
+  if (agent.container?.image) return { image: agent.container.image, source: 'agent' }
+  if (cfg.container?.image) return { image: cfg.container.image, source: 'workforce' }
+  const preset = presetOf(agent)
+  const presetImage = preset ? PRESETS[preset]?.image : undefined
+  if (presetImage && preset) return { image: presetImage, source: `preset:${preset}` }
+  return { image: undefined, source: 'unresolved' }
+}
+interface ComposedMounts {
+  mounts: PresetMount[]
+  mkdirs: string[]
+  cwd: string
+}
+function composeAgentMounts(
+  name: string,
+  agent: AgentConfig,
+  cfg: ZooidConfig,
+  opts: BuildAcpRegistryOptions,
+): ComposedMounts {
+  if (cfg.runtime === 'local') {
+    return { mounts: [], mkdirs: [], cwd: agent.workdir }
+  }
+  const disabled = new Set(agent.container?.disable_mounts ?? [])
+  const knownIds = new Set<string>(['workspace'])
+  const composed: PresetMount[] = []
+  let workspaceActive = false
+  // Layer 1: workspace auto-mount. Skip when explicitly disabled, or when
+  // configDir is missing and the workdir is relative — the daemon path always
+  // passes configDir; tests that exercise other concerns (image resolution,
+  // env) can leave it off without the workspace mount intruding.
+  if (!disabled.has('workspace')) {
+    let host = agent.workdir
+    if (isAbsolute(host)) {
+      composed.push({
+        id: 'workspace',
+        host,
+        target: CONTAINER_WORKDIR,
+        mode: 'rw',
+        create: true,
+      })
+      workspaceActive = true
+    } else if (opts.configDir) {
+      host = pathResolve(opts.configDir, host)
+      composed.push({
+        id: 'workspace',
+        host,
+        target: CONTAINER_WORKDIR,
+        mode: 'rw',
+        create: true,
+      })
+      workspaceActive = true
+    }
+  }
+  // Layer 2: preset mounts.
+  const preset = presetOf(agent)
+  if (preset && PRESETS[preset]?.mounts) {
+    const dataDir = opts.dataDir ?? process.cwd()
+    const ctx = {
+      agentName: name,
+      agentDataDir: pathResolve(dataDir, 'agents', name),
+      containerWorkdir: CONTAINER_WORKDIR,
+      daemonHome: opts.daemonHome ?? process.env.HOME ?? '',
+    }
+    const presetMounts = PRESETS[preset].mounts!(ctx)
+    for (const m of presetMounts) {
+      knownIds.add(m.id)
+      if (!disabled.has(m.id)) composed.push(m)
+    }
+  }
+  // Validate disable_mounts ids — every entry must be either 'workspace' or a
+  // preset-declared id. Unknown ids are typos that would silently no-op.
+  for (const id of disabled) {
+    if (!knownIds.has(id)) {
+      throw new Error(
+        `agents.${name}.container.disable_mounts: unknown id "${id}". ` +
+          `Known ids for this agent: ${[...knownIds].sort().join(', ')}`,
+      )
+    }
+  }
+  // Layer 3: user mounts. Auto-id any without one.
+  const userMounts: MountConfig[] = agent.container?.mounts ?? []
+  let userIdx = 0
+  for (const m of userMounts) {
+    const id = m.id ?? `user-${userIdx}`
+    userIdx++
+    const out: PresetMount = {
+      id,
+      host: m.host,
+      target: m.target,
+      mode: m.mode,
+    }
+    if (m.create !== undefined) out.create = m.create
+    composed.push(out)
+  }
+  const mkdirs: string[] = composed
+    .filter((m) => m.create)
+    .map((m) => m.host)
+  return {
+    mounts: composed,
+    mkdirs,
+    cwd: workspaceActive ? CONTAINER_WORKDIR : agent.workdir,
+  }
 }
 /**
@@ -43,9 +201,11 @@ export interface BuildAcpRegistryOptions {
  *   - `runtime: docker`  → `DockerAcpRuntime` (engine: docker)
  *   - `runtime: podman`  → `DockerAcpRuntime` (engine: podman)
  *
- * Per-agent `container.env` is passed through to each `AcpClient`'s spawn
- * spec verbatim (interpolation happens at parse time in `@zooid/core`).
- * The image is resolved as `agent.container?.image ?? cfg.container?.image`.
+ * Compose layers (docker/podman only): workspace auto-mount → preset-declared
+ * canonical-id mounts (filtered by `container.disable_mounts`) → user mounts.
+ * Image resolution: agent.container.image > workforce container.image >
+ * preset.image. Under `runtime: docker | podman`, throws at startup if any
+ * agent has no resolvable image.
  */
 export function buildAcpRegistry(
   cfg: ZooidConfig,
@@ -57,12 +217,56 @@ export function buildAcpRegistry(
     }
   }
+  // Startup validation: every docker/podman agent must resolve to an image.
+  if (cfg.runtime !== 'local') {
+    const missing: Array<{ name: string; preset?: string }> = []
+    for (const [name, agent] of Object.entries(cfg.agents)) {
+      const { image } = resolveAgentImage(agent, cfg)
+      if (!image) {
+        missing.push({ name, preset: presetOf(agent) })
+      }
+    }
+    if (missing.length > 0) {
+      const lines = missing.map(({ name, preset }) =>
+        `  - ${name}${preset ? ` (preset: ${preset})` : ''} — no preset-default image`,
+      )
+      throw new Error(
+        `runtime: ${cfg.runtime} requires a container image for each agent. Unresolved:\n` +
+          lines.join('\n') +
+          `\nSet agents.<name>.container.image, top-level container.image, or use a ` +
+          `preset that ships a default image (claude, codex, opencode).`,
+      )
+    }
+  }
   const runtime = opts.runtime ?? defaultRuntimeFor(cfg)
   const env: Record<string, Record<string, string>> = {}
   const image: Record<string, string | undefined> = {}
+  const mountsByAgent: Record<string, AcpMount[]> = {}
+  const mkdirByAgent: Record<string, string[]> = {}
+  const cwdByAgent: Record<string, string> = {}
+  const log = opts.log ?? ((line: string) => console.log(line))
   for (const [name, agent] of Object.entries(cfg.agents)) {
     env[name] = agent.container?.env ?? {}
-    image[name] = agent.container?.image ?? cfg.container?.image
+    const { image: resolvedImage, source } = resolveAgentImage(agent, cfg)
+    image[name] = resolvedImage
+    const composed = composeAgentMounts(name, agent, cfg, opts)
+    mountsByAgent[name] = composed.mounts.map((m) => ({
+      path: m.host,
+      target: m.target,
+      mode: m.mode,
+    }))
+    mkdirByAgent[name] = composed.mkdirs
+    cwdByAgent[name] = composed.cwd
+    if (resolvedImage && cfg.runtime !== 'local') {
+      const mountSummary = composed.mounts.length === 0
+        ? 'mounts=[]'
+        : `mounts=[${composed.mounts.map((m) => m.id ?? m.target).join(',')}]`
+      log(
+        `[zooid] agent ${name.padEnd(12)} image=${resolvedImage}  source=${source}  ${mountSummary}`,
+      )
+    }
   }
   const contextSpawns = buildContextSpawns(cfg, opts)
@@ -72,6 +276,9 @@ export function buildAcpRegistry(
     agents: cfg.agents,
     env,
     image,
+    mounts: mountsByAgent,
+    mkdirOnSpawn: mkdirByAgent,
+    cwd: cwdByAgent,
     approvals: opts.approvals,
     onTap: opts.onTap,
     agentsDir: opts.agentsDir,
@@ -87,12 +294,6 @@ function buildContextSpawns(
   const registry = opts.contextSpawnRegistry
   const sockPath = opts.daemonSockPath
-  // Share one MatrixClient per matrix transport (only state is homeserver +
-  // asToken). Per-agent providers wrap that client with the agent's own
-  // user_id as asUserId — when the AS impersonates the agent (via ?user_id=)
-  // it sees the rooms that bot is a member of. The AS sender_localpart
-  // typically isn't in those rooms, so impersonating it returns empty
-  // chunks.
   const matrixClients = new Map<string, MatrixClient>()
   const agentBots = new Map<string, string>()
   for (const [name, agent] of Object.entries(cfg.agents)) {

package/src/build-registry.zod044.test.ts ADDED Viewed

@@ -0,0 +1,261 @@
+import { describe, it, expect } from 'vitest'
+import { buildAcpRegistry } from './build-registry.js'
+import type { ZooidConfig } from '@zooid/core'
+const baseTransports = {
+  m1: {
+    type: 'matrix' as const,
+    homeserver: 'http://localhost:8448',
+    as_token: 't',
+    hs_token: 'h',
+    sender_localpart: 'z',
+    user_namespace: '@.*:localhost',
+  },
+}
+function mkCfg(over: Partial<ZooidConfig['agents']['alice']> = {}): ZooidConfig {
+  return {
+    runtime: 'docker',
+    transports: baseTransports,
+    agents: {
+      alice: {
+        name: 'alice',
+        workdir: './agents/alice',
+        hooks: {},
+        acp: { preset: 'claude' },
+        approval_timeout_ms: 0,
+        matrix: {
+          transport: 'm1',
+          user_id: '@alice:localhost',
+          rooms: ['!r:localhost'],
+          trigger: 'mention',
+        },
+        ...over,
+      },
+    },
+    hooks: {},
+  } as ZooidConfig
+}
+describe('buildAcpRegistry — mounts (ZOD044)', () => {
+  it('auto-injects the workspace mount with id "workspace"', () => {
+    const cfg = mkCfg()
+    const reg = buildAcpRegistry(cfg, {
+      configDir: '/example',
+      dataDir: '/data',
+      daemonHome: '/home/zooid',
+    })
+    const mounts = reg.resolveSpawnMounts('alice')
+    const ws = mounts.find((m) => m.target === '/workspace')
+    expect(ws).toMatchObject({
+      path: '/example/agents/alice',
+      target: '/workspace',
+      mode: 'rw',
+    })
+  })
+  it('overrides cwd to /workspace when workspace mount is active', () => {
+    const cfg = mkCfg()
+    const reg = buildAcpRegistry(cfg, {
+      configDir: '/example',
+      dataDir: '/data',
+      daemonHome: '/home/zooid',
+    })
+    expect(reg.resolveSpawnCwd('alice')).toBe('/workspace')
+  })
+  it('disable_mounts: [workspace] skips auto-mount and passes workdir through to cwd', () => {
+    const cfg = mkCfg({
+      workdir: '/baked/workspace',
+      container: { disable_mounts: ['workspace'] },
+    })
+    const reg = buildAcpRegistry(cfg, {
+      configDir: '/example',
+      dataDir: '/data',
+      daemonHome: '/home/zooid',
+    })
+    const mounts = reg.resolveSpawnMounts('alice')
+    expect(mounts.find((m) => m.target === '/workspace')).toBeUndefined()
+    expect(reg.resolveSpawnCwd('alice')).toBe('/baked/workspace')
+  })
+  it('layers preset mounts after workspace, filtered by disable_mounts', () => {
+    const cfg = mkCfg({ container: { disable_mounts: ['home'] } })
+    const reg = buildAcpRegistry(cfg, {
+      configDir: '/example',
+      dataDir: '/data',
+      daemonHome: '/home/zooid',
+    })
+    const mounts = reg.resolveSpawnMounts('alice')
+    // claude declares one `home` mount; with home disabled, only workspace remains.
+    const targets = mounts.map((m) => m.target)
+    expect(targets).toContain('/workspace')
+    expect(targets).not.toContain('/root/.claude')
+  })
+  it('preset `home` mount points at the daemon user host home, not <dataDir>/agents/<name>', () => {
+    const cfg = mkCfg()
+    const reg = buildAcpRegistry(cfg, {
+      configDir: '/example',
+      dataDir: '/data',
+      daemonHome: '/home/zooid',
+    })
+    const mounts = reg.resolveSpawnMounts('alice')
+    const home = mounts.find((m) => m.target === '/root/.claude')
+    expect(home).toBeDefined()
+    expect(home!.path).toBe('/home/zooid/.claude')
+    expect(home!.path).not.toContain('/data/agents/alice')
+  })
+  it('user-declared mounts append after preset mounts', () => {
+    const cfg = mkCfg({
+      container: {
+        mounts: [{ host: '/srv/shared', target: '/shared', mode: 'rw' }],
+      },
+    })
+    const reg = buildAcpRegistry(cfg, {
+      configDir: '/example',
+      dataDir: '/data',
+      daemonHome: '/home/zooid',
+    })
+    const mounts = reg.resolveSpawnMounts('alice')
+    expect(mounts[mounts.length - 1]).toMatchObject({
+      path: '/srv/shared',
+      target: '/shared',
+    })
+  })
+  it('throws on unknown disable_mounts id', () => {
+    const cfg = mkCfg({ container: { disable_mounts: ['nope'] } })
+    expect(() =>
+      buildAcpRegistry(cfg, {
+        configDir: '/example',
+        dataDir: '/data',
+        daemonHome: '/home/zooid',
+      }),
+    ).toThrow(/disable_mounts.*unknown id.*"nope"/i)
+  })
+  it('runtime: local — no mounts emitted, cwd is workdir verbatim', () => {
+    const cfg = mkCfg()
+    cfg.runtime = 'local'
+    const reg = buildAcpRegistry(cfg, {
+      configDir: '/example',
+      dataDir: '/data',
+      daemonHome: '/home/zooid',
+    })
+    expect(reg.resolveSpawnMounts('alice')).toEqual([])
+    expect(reg.resolveSpawnCwd('alice')).toBe('./agents/alice')
+  })
+})
+describe('buildAcpRegistry — image resolution (ZOD044)', () => {
+  it('uses agent.container.image when set (highest precedence)', () => {
+    const cfg = mkCfg({ container: { image: 'agent-img:v1' } })
+    cfg.container = { image: 'workforce-img:v1' }
+    const reg = buildAcpRegistry(cfg, { configDir: '/example', dataDir: '/data' })
+    expect(reg.resolveSpawnImage('alice')).toBe('agent-img:v1')
+  })
+  it('falls back to workforce-level container.image', () => {
+    const cfg = mkCfg()
+    cfg.container = { image: 'workforce-img:v1' }
+    const reg = buildAcpRegistry(cfg, { configDir: '/example', dataDir: '/data' })
+    expect(reg.resolveSpawnImage('alice')).toBe('workforce-img:v1')
+  })
+  it('falls back to preset.image (claude → ghcr default)', () => {
+    const cfg = mkCfg() // preset: claude, no container.image anywhere
+    const reg = buildAcpRegistry(cfg, { configDir: '/example', dataDir: '/data' })
+    expect(reg.resolveSpawnImage('alice')).toBe('ghcr.io/zooid-ai/agent-claude-code:latest')
+  })
+  it('runtime: docker — throws when an agent has no resolvable image (preset has none)', () => {
+    const cfg = mkCfg({ acp: { preset: 'cline' } })
+    expect(() =>
+      buildAcpRegistry(cfg, { configDir: '/example', dataDir: '/data' }),
+    ).toThrow(/runtime: docker requires a container image[\s\S]*alice[\s\S]*cline/i)
+  })
+  it('runtime: podman — same startup error', () => {
+    const cfg = mkCfg({ acp: { preset: 'gemini' } })
+    cfg.runtime = 'podman'
+    expect(() =>
+      buildAcpRegistry(cfg, { configDir: '/example', dataDir: '/data' }),
+    ).toThrow(/runtime: podman requires a container image/i)
+  })
+  it('runtime: local — never errors on missing image (image is unused)', () => {
+    const cfg = mkCfg({ acp: { preset: 'cline' } })
+    cfg.runtime = 'local'
+    expect(() =>
+      buildAcpRegistry(cfg, { configDir: '/example', dataDir: '/data' }),
+    ).not.toThrow()
+  })
+  it('lists every unresolved agent in a single error', () => {
+    const base = mkCfg()
+    const cfg: ZooidConfig = {
+      runtime: 'podman',
+      transports: baseTransports,
+      agents: {
+        alice: { ...base.agents.alice!, acp: { preset: 'cline' } },
+        bob: {
+          ...base.agents.alice!,
+          name: 'bob',
+          acp: { preset: 'kiro' },
+          matrix: {
+            transport: 'm1',
+            user_id: '@bob:localhost',
+            rooms: ['!r:localhost'],
+            trigger: 'mention',
+          },
+        },
+      },
+      hooks: {},
+    } as ZooidConfig
+    expect(() =>
+      buildAcpRegistry(cfg, { configDir: '/example', dataDir: '/data' }),
+    ).toThrow(/alice[\s\S]*cline[\s\S]*bob[\s\S]*kiro/)
+  })
+})
+describe('buildAcpRegistry — startup discoverability (ZOD044)', () => {
+  it('logs one resolved-image line per agent with provenance', () => {
+    const lines: string[] = []
+    const cfg = mkCfg()
+    buildAcpRegistry(cfg, {
+      configDir: '/example',
+      dataDir: '/data',
+      log: (line) => lines.push(line),
+    })
+    expect(
+      lines.some((l) =>
+        /agent alice.*image=ghcr\.io\/zooid-ai\/agent-claude-code.*source=preset:claude/.test(l),
+      ),
+    ).toBe(true)
+  })
+  it('reports source=agent when the agent overrides the preset default', () => {
+    const lines: string[] = []
+    const cfg = mkCfg({ container: { image: 'custom:v3' } })
+    buildAcpRegistry(cfg, {
+      configDir: '/example',
+      dataDir: '/data',
+      log: (line) => lines.push(line),
+    })
+    expect(lines.some((l) => /agent alice.*image=custom:v3.*source=agent/.test(l))).toBe(true)
+  })
+  it('reports source=workforce when only workforce container.image is set', () => {
+    const lines: string[] = []
+    const cfg = mkCfg()
+    cfg.container = { image: 'wf:v1' }
+    buildAcpRegistry(cfg, {
+      configDir: '/example',
+      dataDir: '/data',
+      log: (line) => lines.push(line),
+    })
+    expect(lines.some((l) => /agent alice.*image=wf:v1.*source=workforce/.test(l))).toBe(true)
+  })
+})

package/src/commands/dev.ts CHANGED Viewed

@@ -66,9 +66,9 @@ export interface DevFlags {
   adminPassword: string
   installSignalHandlers?: boolean
   foreground?: boolean
-  // When true, run `vite build --watch` against the in-tree @zoon/web package
-  // and serve its dist directly. Requires running from the monorepo source.
-  watchWeb?: boolean
+  // Run `vite build --watch` against a @zoon/web package and serve its dist.
+  // true = auto-detect (sibling ../zoon/packages/web or in-monorepo); string = explicit path.
+  watchWeb?: string | boolean
 }
 export interface DevHandle {
@@ -111,7 +111,7 @@ export async function runDev(flags: DevFlags): Promise<DevHandle> {
   process.env.MATRIX_HS_TOKEN = tokens.hsToken
   const rawYaml = readFileSync(found.path, 'utf8')
-  const preview = loadZooidConfig(rawYaml)
+  const preview = loadZooidConfig(rawYaml, { configDir: dirname(found.path) })
   const matrix = findMatrixTransport(preview)
   if (!matrix) {
     throw new Error('zooid.yaml: zooid dev requires at least one matrix transport')
@@ -179,7 +179,7 @@ export async function runDev(flags: DevFlags): Promise<DevHandle> {
       },
       {
         title: 'Start daemon',
-        task: async () => {
+        task: async (_ctx, t) => {
           const captures: Record<string, AgentCapture> = {}
           for (const name of Object.keys(preview.agents)) {
             captures[name] = wireAgentCapture({
@@ -199,6 +199,9 @@ export async function runDev(flags: DevFlags): Promise<DevHandle> {
             adminUserId: `@${flags.adminUser}:${shape.serverName}`,
             agentsDir: layout.agentsDir,
             onTap: (agentName, event) => captures[agentName]?.onTap(event),
+            prepullLog: (line) => {
+              t.output = line.replace(/^\[zooid\]\s+/, '').trim()
+            },
           })
         },
       },
@@ -207,10 +210,15 @@ export async function runDev(flags: DevFlags): Promise<DevHandle> {
             {
               title: 'Start @zoon/web watcher (vite build --watch)',
               task: async (): Promise<void> => {
-                const pkgDir = webSourcePackage(CLI_ROOT)
+                const pkgDir =
+                  typeof flags.watchWeb === 'string'
+                    ? resolve(flags.watchWeb)
+                    : webSourcePackage(CLI_ROOT)
                 if (!pkgDir) {
+                  const defaultPath = dirname(dirname(dirname(CLI_ROOT))) + '/zoon/packages/web'
                   throw new Error(
-                    '--watch-web requires running from the monorepo source (no zoon/packages/web found).',
+                    `--watch-web: @zoon/web not found at ${defaultPath}.\n` +
+                      `Pass an explicit path: --watch-web=/path/to/zoon/packages/web`,
                   )
                 }
                 ctx.webWatch = await startWebWatch({ webPackageDir: pkgDir })

package/src/commands/init/generators.ts CHANGED Viewed

@@ -35,6 +35,11 @@ You are the zooid setup assistant. Your job is to help the operator get a workfo
 - Zooid documentation: https://zooid.dev/docs/
 - Use your web fetch tool to read documentation pages when answering questions.
+## Stack facts
+- **Tuwunel** is a lightweight Rust Matrix homeserver (Conduit fork) backed by RocksDB. Single binary, low resource floor — not "heavy" for typical workforces.
+- **Logs land on disk** in \`./data/\` inside this zooid home dir: tuwunel logs, the daemon, and each agent's ACP stream. Use \`zooid logs <source>\` to tail them (sources: \`tuwunel\`, \`daemon\`, \`dev\`, \`agent-<name>\`, \`agent-<name>.acp\`). Debugging is mostly "read the log file" — don't tell the operator it's opaque.
 ## Behavior
 - Be terse. Give the answer; link to the doc page; stop.