zooid 0.11.2 → 0.13.0

package/src/commands/init/prompts.ts

@@ -1,5 +1,6 @@
 import { select, password } from '@inquirer/prompts'
-import { findOpencodeProvider, findSimplePreset } from './registry.js'
+import { findOpencodeProvider, findPiProvider, findSimplePreset, PI_DEFAULT_PROVIDER } from './registry.js'
+import { sniffCredentials } from './sniff.js'
 import type { InitOptions } from '../init.js'
 
 export interface PromptInput {
@@ -28,9 +29,10 @@ export async function resolveOptions(flags: PromptInput): Promise<InitOptions> {
         { name: 'claude (Claude Code)', value: 'claude' as const },
         { name: 'codex (OpenAI Codex)', value: 'codex' as const },
         { name: 'opencode', value: 'opencode' as const },
+        { name: 'pi', value: 'pi' as const },
       ],
     }),
-    () => '--preset is required (claude | codex | opencode)',
+    () => '--preset is required (claude | codex | opencode | pi)',
   ))
 
   if (preset === 'opencode') {
@@ -64,6 +66,55 @@ export async function resolveOptions(flags: PromptInput): Promise<InitOptions> {
     }
   }
 
+  if (preset === 'pi') {
+    // Offer, never infer: detecting a login only ever adds a question, it
+    // never silently decides the answer.
+    const loginFound = sniffCredentials('pi').found
+    const auth =
+      (flags.auth as 'subscription' | 'api-key') ??
+      (loginFound
+        ? await ask(
+            () =>
+              select({
+                message: 'A pi login was found. How should the agent authenticate?',
+                choices: [
+                  { name: 'Share my pi login (agent uses my existing subscription)', value: 'subscription' as const },
+                  { name: "Give the agent its own key (billed and revoked separately)", value: 'api-key' as const },
+                ],
+              }),
+            () => '--auth is required (subscription | api-key)',
+          )
+        : ('api-key' as const))
+
+    if (auth === 'subscription') {
+      return {
+        dir: flags.dir,
+        preset,
+        auth,
+        force: flags.force,
+        overwrite: flags.overwrite,
+      }
+    }
+
+    const provider = flags.provider ?? PI_DEFAULT_PROVIDER
+    const providerMeta = findPiProvider(provider)
+    if (!providerMeta) throw new Error(`unknown pi provider: ${provider}`)
+    const apiKey = flags.apiKey ?? (await ask(
+      () => password({ message: `${providerMeta.label} API key:` }),
+      () => '--api-key is required',
+    ))
+    return {
+      dir: flags.dir,
+      preset,
+      auth,
+      provider,
+      model: flags.model,
+      apiKey,
+      force: flags.force,
+      overwrite: flags.overwrite,
+    }
+  }
+
   const meta = findSimplePreset(preset)
   if (!meta) throw new Error(`unknown preset: ${preset}`)
   const auth = (flags.auth as 'subscription' | 'api-key') ?? (await ask(

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

@@ -4,6 +4,14 @@ import {
   OPENCODE_PROVIDERS,
   findSimplePreset,
   findOpencodeProvider,
+  PI_PROVIDERS,
+  PI_DEFAULT_PROVIDER,
+  PI_DEFAULT_MODEL,
+  PI_AGENT_DIR,
+  PI_AUTH_FILE,
+  PI_SETTINGS_FILE,
+  PI_AUTH_MODES,
+  findPiProvider,
 } from './registry.js'
 
 describe('init registry', () => {
@@ -31,3 +39,55 @@ describe('init registry', () => {
     expect(findOpencodeProvider('nope')).toBeUndefined()
   })
 })
+
+describe('pi registry (ZOD075)', () => {
+  it('PI_PROVIDERS leads with openrouter, the verified default', () => {
+    expect(PI_PROVIDERS[0]?.id).toBe('openrouter')
+  })
+
+  it('every provider carries an API-key env var', () => {
+    for (const p of PI_PROVIDERS) {
+      expect(p.apiKeyEnvVar).toMatch(/^[A-Z_]+_API_KEY$/)
+      expect(p.label.length).toBeGreaterThan(0)
+    }
+  })
+
+  // anthropic stays reachable, but must not be the default: pi bills Claude
+  // Pro/Max through "extra usage", which starts at zero, so a claude default
+  // 400s for exactly the operator most likely to try Zooid.
+  it('includes anthropic as a choice but not as the default', () => {
+    expect(PI_PROVIDERS.map((p) => p.id)).toContain('anthropic')
+    expect(PI_DEFAULT_PROVIDER).not.toBe('anthropic')
+  })
+
+  it('pins the verified fallback provider and model', () => {
+    expect(PI_DEFAULT_PROVIDER).toBe('openrouter')
+    expect(PI_DEFAULT_MODEL).toBe('deepseek/deepseek-v4-pro')
+  })
+
+  it('findPiProvider returns the entry by id', () => {
+    expect(findPiProvider('openrouter')?.id).toBe('openrouter')
+    expect(findPiProvider('nope')).toBeUndefined()
+  })
+
+  // pi DOES share the subscription-or-key binary (that is what PI_AUTH_MODES
+  // encodes). It stays out of SIMPLE_PRESETS for the other reason: those rows
+  // carry ONE apiKeyEnvVar and ONE credentialDir, and pi needs a provider table.
+  it('pi is NOT in SIMPLE_PRESETS — those rows cannot hold a provider table', () => {
+    expect(SIMPLE_PRESETS.map((p) => p.preset)).not.toContain('pi')
+  })
+
+  it('exposes the agent dir and the home-relative pi paths', () => {
+    expect(PI_AGENT_DIR).toBe('.pi-agent')
+    expect(PI_AUTH_FILE).toBe('.pi/agent/auth.json')
+    expect(PI_SETTINGS_FILE).toBe('.pi/agent/settings.json')
+  })
+})
+
+describe('pi auth binary (ZOD075)', () => {
+  // pi's auth surface is the UNION of the two existing shapes: opencode's
+  // provider table plus claude/codex's subscription-or-api-key binary.
+  it('accepts the same two auth values as claude/codex', () => {
+    expect(PI_AUTH_MODES).toEqual(['subscription', 'api-key'])
+  })
+})

package/src/commands/init/registry.ts

@@ -74,3 +74,61 @@ export function findSimplePreset(name: string): SimplePresetMeta | undefined {
 export function findOpencodeProvider(id: string): OpencodeProviderMeta | undefined {
   return OPENCODE_PROVIDERS.find((p) => p.id === id)
 }
+
+export interface PiProviderMeta {
+  id: string
+  label: string
+  description: string
+  apiKeyEnvVar: string
+}
+
+// ZOD075. pi is multi-provider like opencode, but unlike opencode it also has an
+// OAuth subscription tier (Claude Pro/Max, ChatGPT Plus/Pro, xAI, OpenRouter)
+// whose tokens live in ~/.pi/agent/auth.json — which is why pi gets its own
+// branch instead of a SIMPLE_PRESETS row.
+export const PI_PROVIDERS: readonly PiProviderMeta[] = [
+  {
+    id: 'openrouter',
+    label: 'OpenRouter',
+    description: 'many providers via OpenRouter credits',
+    apiKeyEnvVar: 'OPENROUTER_API_KEY',
+  },
+  {
+    id: 'anthropic',
+    label: 'Anthropic',
+    description: 'Claude via direct Anthropic API key',
+    apiKeyEnvVar: 'ANTHROPIC_API_KEY',
+  },
+  {
+    id: 'openai',
+    label: 'OpenAI',
+    description: 'GPT via direct OpenAI API key',
+    apiKeyEnvVar: 'OPENAI_API_KEY',
+  },
+]
+
+// The ONE pinned model in this wizard, and a deliberate exception to the rule at
+// the top of this file. Every other harness picks its own current default; pi's
+// resolved to a model that returned an empty turn (ZOD073), so pi must be told.
+//
+// Not anthropic: pi bills Claude Pro/Max through "extra usage" (per-token, NOT
+// against the plan), which starts at zero — so a claude default returns
+// `400 "You're out of extra usage"` for the operator most likely to try Zooid,
+// and ACP surfaces that as silence. openrouter/deepseek-v4-pro is the verified
+// fallback; an operator's own global pair is preferred over it (sniffPiDefaults).
+export const PI_DEFAULT_PROVIDER = 'openrouter'
+export const PI_DEFAULT_MODEL = 'deepseek/deepseek-v4-pro'
+
+/** Agent dir, relative so one value is right under both local and container runtimes. */
+export const PI_AGENT_DIR = '.pi-agent'
+/** Home-relative paths to the operator's real pi install. */
+export const PI_AUTH_FILE = '.pi/agent/auth.json'
+export const PI_SETTINGS_FILE = '.pi/agent/settings.json'
+
+// pi's auth surface is the union of the two existing shapes: opencode's
+// provider table plus claude/codex's subscription-or-api-key binary.
+export const PI_AUTH_MODES = ['subscription', 'api-key'] as const
+
+export function findPiProvider(id: string): PiProviderMeta | undefined {
+  return PI_PROVIDERS.find((p) => p.id === id)
+}

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

@@ -1,8 +1,8 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { mkdtempSync, mkdirSync, rmSync } from 'node:fs'
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
-import { sniffCredentials } from './sniff.js'
+import { sniffCredentials, sniffPiDefaults } from './sniff.js'
 
 let fakeHome: string
 
@@ -39,3 +39,62 @@ describe('sniffCredentials', () => {
     expect(sniffCredentials('claude', fakeHome).found).toBe(true)
   })
 })
+
+describe('sniffCredentials — pi (ZOD075)', () => {
+  // pi's credential is a FILE, not a directory like ~/.claude — existsSync
+  // covers both, but the path must point at auth.json.
+  it('reports found when ~/.pi/agent/auth.json exists', () => {
+    mkdirSync(join(fakeHome, '.pi', 'agent'), { recursive: true })
+    writeFileSync(join(fakeHome, '.pi', 'agent', 'auth.json'), '{}')
+    const r = sniffCredentials('pi', fakeHome)
+    expect(r.found).toBe(true)
+    expect(r.path).toMatch(/auth\.json$/)
+  })
+
+  it('reports not-found when ~/.pi is absent', () => {
+    expect(sniffCredentials('pi', fakeHome).found).toBe(false)
+  })
+
+  it('reports not-found when ~/.pi/agent exists but holds no auth.json', () => {
+    mkdirSync(join(fakeHome, '.pi', 'agent'), { recursive: true })
+    expect(sniffCredentials('pi', fakeHome).found).toBe(false)
+  })
+})
+
+describe('sniffPiDefaults (ZOD075)', () => {
+  const write = (obj: unknown) => {
+    mkdirSync(join(fakeHome, '.pi', 'agent'), { recursive: true })
+    writeFileSync(join(fakeHome, '.pi', 'agent', 'settings.json'), JSON.stringify(obj))
+  }
+
+  // Inheriting a pair the operator already runs interactively beats any default
+  // this repo could guess — it is verified by use.
+  it('inherits defaultProvider and defaultModel from the global settings', () => {
+    write({ theme: 'dark', defaultProvider: 'openrouter', defaultModel: 'deepseek/deepseek-v4-flash' })
+    expect(sniffPiDefaults(fakeHome)).toEqual({
+      provider: 'openrouter',
+      model: 'deepseek/deepseek-v4-flash',
+      source: join(fakeHome, '.pi', 'agent', 'settings.json'),
+    })
+  })
+
+  it('returns undefined when no settings file exists', () => {
+    expect(sniffPiDefaults(fakeHome)).toBeUndefined()
+  })
+
+  // A settings file that pins neither is the common case for a casual pi user;
+  // half a pair is not inheritable either.
+  it('returns undefined when the pair is absent or incomplete', () => {
+    write({ theme: 'dark' })
+    expect(sniffPiDefaults(fakeHome)).toBeUndefined()
+    write({ defaultProvider: 'openrouter' })
+    expect(sniffPiDefaults(fakeHome)).toBeUndefined()
+  })
+
+  // Never let a corrupt personal config abort someone's onboarding.
+  it('returns undefined rather than throwing on malformed JSON', () => {
+    mkdirSync(join(fakeHome, '.pi', 'agent'), { recursive: true })
+    writeFileSync(join(fakeHome, '.pi', 'agent', 'settings.json'), '{not json')
+    expect(sniffPiDefaults(fakeHome)).toBeUndefined()
+  })
+})

package/src/commands/init/sniff.ts

@@ -1,30 +1,61 @@
-import { existsSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
-import { findSimplePreset } from './registry.js'
+import { findSimplePreset, PI_AUTH_FILE, PI_SETTINGS_FILE } from './registry.js'
 
 export interface SniffResult {
   found: boolean
-  /** Absolute path that satisfied the sniff (the config directory). */
+  /** Absolute path that satisfied the sniff (the config directory, or file for pi). */
   path?: string
 }
 
 /**
- * Checks whether the operator's per-CLI config directory exists. NEVER reads
- * any file inside — only `existsSync` on the dir. One rule covers Linux,
- * macOS Keychain, and OS keyring without per-backend logic. The edge case
- * where the dir exists but the operator isn't actually logged in is accepted;
- * the spawned shim will surface a clearer error on first turn.
+ * Checks whether the operator's per-CLI config directory (or, for pi, the
+ * credential file) exists. NEVER reads any file inside — only `existsSync`.
+ * One rule covers Linux, macOS Keychain, and OS keyring without per-backend
+ * logic. The edge case where the dir exists but the operator isn't actually
+ * logged in is accepted; the spawned shim will surface a clearer error on
+ * first turn.
  *
  * `home` is overridable for tests.
  */
 export function sniffCredentials(
-  preset: 'claude' | 'codex',
+  preset: 'claude' | 'codex' | 'pi',
   home: string = homedir(),
 ): SniffResult {
-  const meta = findSimplePreset(preset)
-  if (!meta) return { found: false }
-  const full = join(home, meta.credentialDir)
+  // pi's credential is a file (auth.json), not a directory; existsSync covers
+  // both, so the only difference is which relative path we join.
+  const rel = preset === 'pi' ? PI_AUTH_FILE : findSimplePreset(preset)?.credentialDir
+  if (!rel) return { found: false }
+  const full = join(home, rel)
   if (existsSync(full)) return { found: true, path: full }
   return { found: false }
 }
+
+export interface PiDefaults {
+  provider: string
+  model: string
+  /** Absolute path the pair came from, so the wizard can say where. */
+  source: string
+}
+
+/**
+ * Reads the operator's global pi defaults. A pair they already run
+ * interactively is verified by use, which beats any pin this repo could guess.
+ *
+ * Returns undefined unless BOTH keys are present — half a pair cannot boot pi.
+ * Never throws: a corrupt personal config must not abort onboarding.
+ */
+export function sniffPiDefaults(home: string = homedir()): PiDefaults | undefined {
+  const source = join(home, PI_SETTINGS_FILE)
+  try {
+    const raw = JSON.parse(readFileSync(source, 'utf8')) as Record<string, unknown>
+    const provider = raw.defaultProvider
+    const model = raw.defaultModel
+    if (typeof provider !== 'string' || !provider) return undefined
+    if (typeof model !== 'string' || !model) return undefined
+    return { provider, model, source }
+  } catch {
+    return undefined
+  }
+}

package/src/commands/init.ts

@@ -1,4 +1,5 @@
-import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readdirSync, symlinkSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
 import { dirname, join, resolve } from 'node:path'
 import {
   generateAgentsMd,
@@ -8,22 +9,28 @@ import {
   generateGitignore,
   generateOpencodeJson,
   generateOpencodeReadme,
+  generatePiSettings,
   generateZooidYaml,
 } from './init/generators.js'
 import {
   findOpencodeProvider,
+  findPiProvider,
   findSimplePreset,
+  PI_AGENT_DIR,
+  PI_AUTH_FILE,
+  PI_DEFAULT_MODEL,
+  PI_DEFAULT_PROVIDER,
 } from './init/registry.js'
-import { sniffCredentials } from './init/sniff.js'
+import { sniffCredentials, sniffPiDefaults } from './init/sniff.js'
 
 export interface InitOptions {
   dir: string
-  preset: 'claude' | 'codex' | 'opencode'
-  /** Required for claude/codex; ignored for opencode. */
+  preset: 'claude' | 'codex' | 'opencode' | 'pi'
+  /** Required for claude/codex/pi; ignored for opencode. */
   auth?: 'subscription' | 'api-key'
   /** Optional model pin. Omitted by default — the harness uses its own default. */
   model?: string
-  /** opencode provider id; defaults to `opencode-go` in the wizard. */
+  /** opencode/pi provider id; defaults to `opencode-go` for opencode. */
   provider?: string
   /** Required on api-key path; required for opencode. */
   apiKey?: string
@@ -31,6 +38,8 @@ export interface InitOptions {
   force?: boolean
   /** Required with `force` to overwrite existing files. */
   overwrite?: boolean
+  /** Overridable for tests; defaults to os.homedir(). */
+  home?: string
 }
 
 interface WriteSpec {
@@ -66,6 +75,7 @@ export async function runInit(opts: InitOptions): Promise<void> {
   }
 
   const writes: WriteSpec[] = []
+  let piInherited: { provider: string; model: string; source: string } | undefined
 
   if (opts.preset === 'claude' || opts.preset === 'codex') {
     if (!opts.auth) throw new Error('--auth (subscription|api-key) is required for claude/codex')
@@ -123,6 +133,47 @@ export async function runInit(opts: InitOptions): Promise<void> {
         content: generateEnv({ envVar: providerMeta!.apiKeyEnvVar, value: opts.apiKey! }),
       })
     }
+  } else if (opts.preset === 'pi') {
+    // Same binary as claude/codex, because pi has the same two tiers. The
+    // difference is that the api-key side also needs a provider.
+    if (!opts.auth) throw new Error('--auth (subscription|api-key) is required for pi')
+    if (opts.auth === 'subscription' && !sniffCredentials('pi', opts.home).found) {
+      throw new Error(
+        'no pi login found — run `pi` and /login first, or use --auth api-key',
+      )
+    }
+    if (opts.auth === 'api-key' && !opts.provider) {
+      throw new Error('--provider is required for pi --auth api-key')
+    }
+    const providerMeta = opts.provider ? findPiProvider(opts.provider) : undefined
+    if (opts.provider && !providerMeta) throw new Error(`unknown pi provider: ${opts.provider}`)
+
+    // Inherit before pinning: a pair the operator already runs interactively is
+    // verified by use. Explicit flags still win over an inherited value.
+    const inherited = sniffPiDefaults(opts.home)
+    const provider = opts.provider ?? inherited?.provider ?? PI_DEFAULT_PROVIDER
+    const model = opts.model ?? inherited?.model ?? PI_DEFAULT_MODEL
+    const settingsProvider = opts.model ? provider : (inherited?.provider ?? provider)
+
+    writes.push({ path: 'zooid.yaml', content: generateZooidYaml({ preset: 'pi' }) })
+    writes.push({ path: 'agents/zooid-assistant/AGENTS.md', content: generateAgentsMd() })
+    writes.push({
+      path: `agents/zooid-assistant/${PI_AGENT_DIR}/settings.json`,
+      content: generatePiSettings({ provider: settingsProvider, model }),
+    })
+
+    // PI_CODING_AGENT_DIR is relative on purpose: the agent's cwd is
+    // agents/<name> locally and /workspace in a container, and those are the
+    // same directory, so one value is correct under both runtimes (spike 1.1).
+    const envLines = [`PI_CODING_AGENT_DIR=${PI_AGENT_DIR}`]
+    // Only the api-key path writes a key. The subscription path shares the
+    // operator's auth.json instead (below) and writes no credential here.
+    if (opts.auth === 'api-key' && opts.apiKey) {
+      envLines.push(`${providerMeta!.apiKeyEnvVar}=${opts.apiKey}`)
+    }
+    writes.push({ path: '.env', content: envLines.join('\n') + '\n' })
+
+    piInherited = inherited
   } else {
     throw new Error(`unknown preset: ${String(opts.preset)}`)
   }
@@ -152,5 +203,40 @@ export async function runInit(opts: InitOptions): Promise<void> {
     }
   }
 
+  if (opts.preset === 'pi') {
+    if (piInherited) {
+      console.log(
+        `✓ Inherited defaultProvider=${piInherited.provider} defaultModel=${piInherited.model} from ${piInherited.source}`,
+      )
+    } else {
+      console.log(
+        `✓ Pinned defaultProvider=${PI_DEFAULT_PROVIDER} defaultModel=${PI_DEFAULT_MODEL} (pi's own default returns an empty turn)`,
+      )
+    }
+    const s = sniffCredentials('pi', opts.home)
+    if (opts.auth === 'subscription' && s.found) {
+      // Symlink, not copy: pi rotates OAuth tokens via temp-file-and-rename
+      // (spike 1.2), which a symlink survives because it names a path, not an
+      // inode. Host-path only — this wizard only ever scaffolds `runtime:
+      // local`, so the operator's real ~/.pi/agent/auth.json is the same file
+      // the local agent process resolves against.
+      const authSource = join(opts.home ?? homedir(), PI_AUTH_FILE)
+      const linkPath = join(dir, `agents/zooid-assistant/${PI_AGENT_DIR}/auth.json`)
+      if (!existsSync(linkPath)) {
+        mkdirSync(dirname(linkPath), { recursive: true })
+        symlinkSync(authSource, linkPath)
+      }
+      console.log(
+        `✓ Shared pi login from ${s.path} — the agent uses your subscription via a symlink at ${PI_AGENT_DIR}/auth.json`,
+      )
+    } else if (s.found) {
+      console.log(
+        `✓ Found pi login at ${s.path} — the agent gets its own config at ${PI_AGENT_DIR}/ and will not touch it`,
+      )
+    } else {
+      console.warn(`⚠ No pi login detected — the agent uses its own API key from .env`)
+    }
+  }
+
   console.log('\nNext: zooid dev')
 }

package/src/commands/status.test.ts

@@ -54,6 +54,21 @@ describe('collectStatus', () => {
     ])
   })
 
+  it('reports the VAPID public key when vapid.json exists in the data dir', async () => {
+    writeFileSync(join(dir, 'zooid.yaml'), yaml)
+    writeFileSync(join(dir, 'vapid.json'), JSON.stringify({ publicKey: 'BPk', privateKey: 'priv' }))
+    vi.stubGlobal('fetch', vi.fn(async () => new Response('not found', { status: 404 })))
+    const s = await collectStatus({ cwd: dir, tuwunelUrl: 'http://localhost:8448', dataDir: dir })
+    expect(s.vapidPublicKey).toBe('BPk')
+  })
+
+  it('omits the VAPID key when no daemon has run yet', async () => {
+    writeFileSync(join(dir, 'zooid.yaml'), yaml)
+    vi.stubGlobal('fetch', vi.fn(async () => new Response('not found', { status: 404 })))
+    const s = await collectStatus({ cwd: dir, tuwunelUrl: 'http://localhost:8448', dataDir: dir })
+    expect(s.vapidPublicKey).toBeUndefined()
+  })
+
   it('reports daemon down when the AS callback port refuses the connection', async () => {
     writeFileSync(join(dir, 'zooid.yaml'), yaml)
     vi.stubGlobal(

package/src/commands/status.ts

@@ -1,8 +1,9 @@
 import { readFileSync } from 'node:fs'
-import { dirname } from 'node:path'
+import { dirname, join, resolve } from 'node:path'
 import chalk from 'chalk'
 import { findConfigFile, findMatrixTransport, loadZooidConfig } from '@zooid/core'
 import { deriveHomeserverShape } from '../bootstrap/derive.js'
+import { VAPID_FILENAME } from '../push-gateway/vapid.js'
 
 export interface StatusFlags {
   cwd?: string
@@ -15,6 +16,24 @@ export interface StatusReport {
   tuwunel: { status: 'up' | 'down'; url: string }
   daemon: { status: 'up' | 'down'; url: string } | { status: 'unknown'; reason: string }
   agents: { name: string; userId: string; trigger: string }[]
+  /** VAPID public key read from `<dataDir>/vapid.json`, when it exists. */
+  vapidPublicKey?: string
+}
+
+/**
+ * Read the daemon's VAPID public key straight off disk. Operators
+ * hand-editing a box's config.json need it and can't start a daemon just to
+ * ask, so this reads the persisted file rather than starting one.
+ */
+export function readVapidPublicKey(dataDir: string): string | undefined {
+  try {
+    const parsed = JSON.parse(readFileSync(join(dataDir, VAPID_FILENAME), 'utf8')) as {
+      publicKey?: string
+    }
+    return typeof parsed.publicKey === 'string' ? parsed.publicKey : undefined
+  } catch {
+    return undefined
+  }
 }
 
 async function probe(url: string, timeoutMs = 2_000): Promise<boolean> {
@@ -29,12 +48,14 @@ async function probe(url: string, timeoutMs = 2_000): Promise<boolean> {
 export async function collectStatus(opts: {
   cwd: string
   tuwunelUrl: string
+  dataDir?: string
 }): Promise<StatusReport> {
   const tuwunelUp = await probe(`${opts.tuwunelUrl}/_matrix/client/versions`)
   const tuwunel: StatusReport['tuwunel'] = {
     status: tuwunelUp ? 'up' : 'down',
     url: opts.tuwunelUrl,
   }
+  const vapidPublicKey = opts.dataDir ? readVapidPublicKey(opts.dataDir) : undefined
 
   const found = findConfigFile(opts.cwd)
   if (!found) {
@@ -42,6 +63,7 @@ export async function collectStatus(opts: {
       tuwunel,
       daemon: { status: 'unknown', reason: 'no zooid.yaml' },
       agents: [],
+      ...(vapidPublicKey ? { vapidPublicKey } : {}),
     }
   }
   const cfg = loadZooidConfig(readFileSync(found.path, 'utf8'), {
@@ -67,6 +89,7 @@ export async function collectStatus(opts: {
     tuwunel,
     daemon: { status: daemonUp ? 'up' : 'down', url: daemonUrl },
     agents,
+    ...(vapidPublicKey ? { vapidPublicKey } : {}),
   }
 }
 
@@ -89,7 +112,8 @@ export async function runStatus(flags: StatusFlags): Promise<void> {
     }
   }
   const tuwunelUrl = `http://localhost:${port ?? 8448}`
-  const s = await collectStatus({ cwd, tuwunelUrl })
+  const dataDir = resolve(cwd, flags.dataDir ?? './data')
+  const s = await collectStatus({ cwd, tuwunelUrl, dataDir })
   const fmt = (st: 'up' | 'down' | 'unknown'): string =>
     st === 'up' ? chalk.green('up') : st === 'down' ? chalk.red('down') : chalk.yellow('unknown')
   process.stdout.write(
@@ -99,6 +123,7 @@ export async function runStatus(flags: StatusFlags): Promise<void> {
       ...s.agents.map(
         (a) => `  agent: ${a.name} (${a.userId}, trigger: ${a.trigger})`,
       ),
+      ...(s.vapidPublicKey ? [`vapid public key: ${s.vapidPublicKey}`] : []),
       '',
     ].join('\n'),
   )

package/src/daemon/start-daemon.ts

@@ -33,6 +33,7 @@ import {
 } from '@zooid/context-mcp'
 import { buildAcpRegistry } from '../build-registry.js'
 import { prepullImages } from '../prepull-images.js'
+import { mountPushGateway } from '../push-gateway/index.js'
 import { makeSyncCursorStore } from './sync-cursors.js'
 import { shouldBindHttpListener } from './pull-wiring.js'
 
@@ -79,6 +80,8 @@ export interface StartDaemonOpts {
 export interface DaemonHandle {
   port: number
   agentNames: string[]
+  /** VAPID public key for web push, when the gateway bound (appservice mode with a data dir). */
+  vapidPublicKey?: string
   stop(): Promise<void>
   whenStopped: Promise<void>
 }
@@ -166,6 +169,7 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
 
   const matrix = findMatrixTransport(config)
   let port: number
+  let vapidPublicKey: string | undefined
 
   if (matrix) {
     const mode = matrix.transport.mode ?? 'appservice'
@@ -232,6 +236,16 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
     })
     if (shouldBindHttpListener(mode)) {
       const requestedPort = matrix.transport.port ?? 9000
+      // The gateway rides the appservice listener, not webStatic: webStatic
+      // exists only under `zooid dev`, and on a deployed box Caddy serves the
+      // dist directly with the daemon out of the serving path. This is the
+      // one HTTP surface bound in both modes.
+      if (dataDir) {
+        vapidPublicKey = mountPushGateway(transport.app, {
+          dataDir,
+          subject: `https://${serverName}`,
+        }).publicKey
+      }
       // 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>.
@@ -347,5 +361,5 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
     process.on('SIGTERM', () => handler('SIGTERM'))
   }
 
-  return { port, agentNames, stop, whenStopped }
+  return { port, agentNames, vapidPublicKey, stop, whenStopped }
 }