zooid 0.11.2 → 0.13.0

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zooid",
-  "version": "0.11.2",
+  "version": "0.13.0",
   "description": "An open-source, self-hostable chat app for collaborating with AI agents alongside your team. Any model, any CLI.",
   "type": "module",
   "license": "MIT",
@@ -25,7 +25,7 @@
     "access": "public"
   },
   "zooid": {
-    "webVersion": "0.10.0"
+    "webVersion": "0.11.0"
   },
   "engines": {
     "node": ">=22"
@@ -40,19 +40,21 @@
     "marked": "^18.0.4",
     "sanitize-html": "^2.17.4",
     "tar": "^7.5.16",
+    "web-push": "^3.6.7",
     "yaml": "^2.5.0",
-    "@zooid/acp-client": "^0.11.2",
-    "@zooid/core": "^0.11.2",
-    "@zooid/runtime-docker": "^0.11.2",
-    "@zooid/runtime-local": "^0.11.2",
-    "@zooid/context-mcp": "^0.11.2",
-    "@zooid/transport-matrix": "^0.11.2",
-    "@zooid/transport-http": "^0.11.2"
+    "@zooid/acp-client": "^0.13.0",
+    "@zooid/transport-matrix": "^0.13.0",
+    "@zooid/context-mcp": "^0.13.0",
+    "@zooid/core": "^0.13.0",
+    "@zooid/runtime-local": "^0.13.0",
+    "@zooid/runtime-docker": "^0.13.0",
+    "@zooid/transport-http": "^0.13.0"
   },
   "devDependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",
     "@playwright/test": "^1.49.0",
     "@types/node": "^22.0.0",
+    "@types/web-push": "^3.6.4",
     "release-it": "^19.2.4",
     "tsup": "^8.5.1",
     "tsx": "^4.19.0",

package/src/bin.test.ts

@@ -0,0 +1,63 @@
+import { spawnSync } from 'node:child_process'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+const TSX = join(HERE, '..', 'node_modules', '.bin', 'tsx')
+const BIN = join(HERE, 'bin.ts')
+
+function runCli(args: string[]) {
+  const result = spawnSync(TSX, [BIN, ...args], { encoding: 'utf8' })
+  return { stdout: result.stdout, stderr: result.stderr, status: result.status }
+}
+
+describe('zooid help', () => {
+  it('lists every registered command with no args', () => {
+    const { stdout, status } = runCli([])
+    expect(status).toBe(1)
+    for (const name of ['start', 'dev', 'logs', 'status', 'init', 'help']) {
+      expect(stdout).toContain(name)
+    }
+  })
+
+  it('--help prints the same command list and exits 0', () => {
+    const { stdout, status } = runCli(['--help'])
+    expect(status).toBe(0)
+    expect(stdout).toContain('Commands:')
+    expect(stdout).toContain('init [dir]')
+  })
+
+  it('`zooid help` mirrors `zooid --help`', () => {
+    const { stdout, status } = runCli(['help'])
+    expect(status).toBe(0)
+    expect(stdout).toContain('Commands:')
+  })
+
+  it('`zooid help <command>` shows that command\'s own help', () => {
+    const { stdout, status } = runCli(['help', 'init'])
+    expect(status).toBe(0)
+    expect(stdout).toContain('$ zooid init [dir]')
+    expect(stdout).toContain('--preset <name>')
+  })
+
+  it('`zooid <command> --help` still works directly', () => {
+    const { stdout, status } = runCli(['logs', '--help'])
+    expect(status).toBe(0)
+    expect(stdout).toContain('$ zooid logs [source]')
+  })
+
+  it('rejects an unknown subcommand of help', () => {
+    const { stdout, stderr, status } = runCli(['help', 'bogus'])
+    expect(status).toBe(1)
+    expect(stderr).toContain('Unknown command: bogus')
+    expect(stdout).toContain('Commands:')
+  })
+
+  it('rejects an unknown top-level command instead of exiting silently', () => {
+    const { stdout, stderr, status } = runCli(['frobnicate'])
+    expect(status).toBe(1)
+    expect(stderr).toContain('Unknown command: frobnicate')
+    expect(stdout).toContain('Commands:')
+  })
+})

package/src/bin.ts

@@ -6,6 +6,7 @@ import { resolveOptions } from './commands/init/prompts.js'
 import { runLogs } from './commands/logs.js'
 import { runStart } from './commands/start.js'
 import { runStatus } from './commands/status.js'
+import { CLI_VERSION } from './version.js'
 
 const cli = cac('zooid')
 
@@ -15,6 +16,8 @@ cli
   .option('--runtime <local|docker|podman>', 'Agent runtime')
   .option('--image <ref>', 'Agent container image')
   .option('--print-token', 'Print a 32-byte hex token and exit')
+  .example('$ zooid start --data ./data')
+  .example('$ zooid start --runtime docker --image ghcr.io/zooid-ai/agent:latest')
   .action(async (flags) => {
     await runStart({
       dataDir: flags.data,
@@ -35,6 +38,8 @@ cli
     '--watch-web [path]',
     'Run vite build --watch on @zooid/web. Path defaults to sibling ../zooid-clients/packages/web.',
   )
+  .example('$ zooid dev')
+  .example('$ zooid dev --engine podman --ui-port 5174')
   .action(async (flags) => {
     await runDev({
       dataDir: flags.data,
@@ -56,6 +61,9 @@ cli
   .option('--turn <id>', 'Filter ACP taps to a single turn id')
   .option('-f, --follow', 'Tail the file (not yet implemented)')
   .option('--keep <n>', 'For `logs prune`: days to retain', { default: 14 })
+  .example('$ zooid logs daemon')
+  .example('$ zooid logs agent-support.acp --turn 3f9c1a --day 2026-09-06')
+  .example('$ zooid logs prune --keep 7')
   .action(async (source, flags) => {
     if (source === 'prune') {
       await runLogs({
@@ -78,6 +86,7 @@ cli
   .command('status', 'Print Tuwunel + daemon health')
   .option('--data <dir>', 'Persistent data root dir', { default: './data' })
   .option('--port <n>', 'Tuwunel host port (defaults to zooid.yaml)')
+  .example('$ zooid status')
   .action(async (flags) => {
     await runStatus({
       dataDir: flags.data,
@@ -87,14 +96,17 @@ cli
 
 cli
   .command('init [dir]', 'Scaffold a new zooid workforce in the current (or named) directory')
-  .option('--preset <name>', 'claude | codex | opencode')
-  .option('--auth <mode>', 'subscription | api-key (claude/codex only)')
+  .option('--preset <name>', 'claude | codex | opencode | pi')
+  .option('--auth <mode>', 'subscription | api-key (claude/codex/pi only)')
   .option('--model <id>', 'Model identifier')
-  .option('--provider <id>', 'opencode provider: opencode-go | opencode | anthropic | openrouter | custom')
+  .option('--provider <id>', 'opencode provider: opencode-go | opencode | anthropic | openrouter | custom; pi provider: openrouter | anthropic | openai')
   .option('--api-key <value>', 'API key (api-key path; opencode always)')
   .option('--force', 'Allow scaffolding into a non-empty directory')
   .option('--overwrite', 'With --force, overwrite existing files')
   .option('--no-interactive', 'Disable prompts; require all flags up front')
+  .example('$ zooid init')
+  .example('$ zooid init my-workforce --preset opencode --provider anthropic')
+  .example('$ zooid init --preset claude --auth api-key --api-key sk-... --no-interactive')
   .action(async (dir: string | undefined, flags) => {
     const resolved = await resolveOptions({
       dir: dir ?? process.cwd(),
@@ -110,6 +122,43 @@ cli
     await runInit(resolved)
   })
 
-cli.help()
-cli.version('0.0.1')
-cli.parse()
+cli
+  .command('help [command]', 'Display help for zooid, or for a specific command')
+  .example('$ zooid help')
+  .example('$ zooid help init')
+  .action((commandName?: string) => {
+    if (!commandName) {
+      cli.globalCommand.outputHelp()
+      return
+    }
+    const target = cli.commands.find((c) => c.isMatched(commandName))
+    if (!target) {
+      console.error(`Unknown command: ${commandName}\n`)
+      cli.globalCommand.outputHelp()
+      process.exitCode = 1
+      return
+    }
+    target.outputHelp()
+  })
+
+cli.help((sections) => {
+  sections.push({
+    title: 'Docs',
+    body: '  https://zooid.dev/docs',
+  })
+  return sections
+})
+cli.version(CLI_VERSION)
+
+cli.on('command:*', () => {
+  console.error(`Unknown command: ${cli.args.join(' ')}\n`)
+  cli.outputHelp()
+  process.exitCode = 1
+})
+
+if (process.argv.slice(2).length === 0) {
+  cli.outputHelp()
+  process.exitCode = 1
+} else {
+  cli.parse()
+}

package/src/bootstrap/configs.test.ts

@@ -15,6 +15,13 @@ describe('renderTuwunelToml', () => {
     )
     expect(toml).toContain('allow_local_presence = true')
     expect(toml).toContain('port = [8448]')
+    // Presence-based push suppression stays OFF — sw.js suppresses per-room
+    // on visibility instead, and presence lingers long past a closed tab.
+    expect(toml).not.toContain('suppress_push_when_active')
+    // DEV ONLY: Tuwunel is in Podman, the push gateway runs on the host, and
+    // the default ip_range_denylist (127/8, 10/8, 172.16/12, 192.168/16, ::1)
+    // would silently drop every pusher delivery to it.
+    expect(toml).toContain('ip_range_denylist = []')
   })
 
   it('honors a non-default server_name', () => {

package/src/bootstrap/configs.ts

@@ -26,6 +26,20 @@ export function renderTuwunelToml(opts: TuwunelTomlOpts): string {
     'allow_local_presence = true',
     'address = ["0.0.0.0"]',
     `port = [${TUWUNEL_INTERNAL_PORT}]`,
+    // NOT `suppress_push_when_active` ([[ZNC025]]). It reads Matrix presence,
+    // which is both too coarse and too slow for this: coarse because it is
+    // per-user, so reading room A kills the push for room B; slow because
+    // `currently_active` lingers for minutes after the last sync, so closing
+    // the tab and waiting for an agent to finish still delivers nothing —
+    // exactly the case this feature exists for. `public/sw.js` already does
+    // the suppression we actually want, precisely: it drops a push only when
+    // a *visible* window is on *that* room.
+    // DEV ONLY — disables an SSRF guard. Tuwunel is in Podman and the push
+    // gateway runs on the host, so the default ip_range_denylist (127/8,
+    // 10/8, 172.16/12, 192.168/16, ::1) silently drops every pusher delivery.
+    // Never set on a box: there the gateway is reached at the public
+    // hostname through Caddy.
+    'ip_range_denylist = []',
     '',
   ].join('\n')
 }

package/src/build-registry.ts

@@ -234,7 +234,7 @@ export function buildAcpRegistry(
         `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).`,
+          `preset that ships a default image (claude, codex, opencode, pi).`,
       )
     }
   }

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

@@ -220,6 +220,29 @@ describe('buildAcpRegistry — image resolution (ZOD044)', () => {
   })
 })
 
+describe('pi image resolution (ZOD073)', () => {
+  it('resolves a pi agent to the preset default image under runtime: docker', () => {
+    const cfg = mkCfg({ acp: { preset: 'pi' } })
+    const reg = buildAcpRegistry(cfg, { configDir: '/example', dataDir: '/data' })
+    expect(reg.resolveSpawnImage('alice')).toBe('ghcr.io/zooid-ai/agent-pi:latest')
+  })
+
+  it('lets agents.<name>.container.image override the pi default', () => {
+    const cfg = mkCfg({ acp: { preset: 'pi' }, container: { image: 'local/pi:dev' } })
+    const reg = buildAcpRegistry(cfg, { configDir: '/example', dataDir: '/data' })
+    expect(reg.resolveSpawnImage('alice')).toBe('local/pi:dev')
+  })
+
+  // Before this cycle, a pi agent under docker threw at startup with
+  // "no preset-default image". That error must stop naming pi.
+  it('does not throw the unresolved-image startup error for pi', () => {
+    const cfg = mkCfg({ acp: { preset: 'pi' } })
+    expect(() =>
+      buildAcpRegistry(cfg, { configDir: '/example', dataDir: '/data' }),
+    ).not.toThrow()
+  })
+})
+
 describe('buildAcpRegistry — startup discoverability (ZOD044)', () => {
   it('logs one resolved-image line per agent with provenance', () => {
     const lines: string[] = []

package/src/commands/dev.ts

@@ -248,7 +248,22 @@ export async function runDev(flags: DevFlags): Promise<DevHandle> {
                 t.output = msg
               },
             }))
-          const app = webStatic({ webRoot, homeserverUrl: homeserver })
+          const app = webStatic({
+            webRoot,
+            homeserverUrl: homeserver,
+            ...(ctx.daemon?.vapidPublicKey
+              ? {
+                  // Tuwunel runs in a container; `localhost` here would
+                  // resolve to the container, not the daemon. Same shorthand
+                  // as the AS registration url
+                  // (bootstrap/registration-url.ts). This URL is stored in
+                  // the pusher and fetched by the homeserver — the browser
+                  // never requests it.
+                  pushGatewayUrl: `http://host.docker.internal:${ctx.daemon.port}/_matrix/push/v1/notify`,
+                  vapidPublicKey: ctx.daemon.vapidPublicKey,
+                }
+              : {}),
+          })
           ctx.uiServer = serve({ fetch: app.fetch, port: flags.uiPort })
         },
       },
@@ -287,13 +302,28 @@ export async function runDev(flags: DevFlags): Promise<DevHandle> {
   })
 
   if (flags.installSignalHandlers !== false) {
-    const handler = async (): Promise<void> => {
-      process.stdout.write(chalk.dim('\nStopping…\n'))
-      await shutdown()
-      process.exit(0)
+    // buildShutdown is idempotent, so a repeat Ctrl-C used to print again and
+    // await the same promise, with no way to give up on a step taking too
+    // long. Escalate on repeats instead.
+    let interrupts = 0
+    const onSignal = (): void => {
+      interrupts += 1
+      if (interrupts === 1) {
+        process.stdout.write(chalk.dim('\nStopping…\n'))
+        void shutdown().then(() => process.exit(0))
+        return
+      }
+      if (interrupts === 2) {
+        process.stdout.write(
+          chalk.dim('Still stopping — press Ctrl-C again to force quit.\n'),
+        )
+        return
+      }
+      process.stdout.write(chalk.dim('Forced.\n'))
+      process.exit(130)
     }
-    process.on('SIGINT', () => void handler())
-    process.on('SIGTERM', () => void handler())
+    process.on('SIGINT', onSignal)
+    process.on('SIGTERM', onSignal)
   }
 
   process.stdout.write(

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

@@ -6,6 +6,7 @@ import {
   generateOpencodeJson,
   generateEnv,
   generateGitignore,
+  generatePiSettings,
 } from './generators.js'
 
 describe('generateZooidYaml', () => {
@@ -113,3 +114,45 @@ describe('generateGitignore', () => {
     expect(out).toContain('data/')
   })
 })
+
+describe('generatePiSettings (ZOD075)', () => {
+  it('writes only the two keys pi needs to boot', () => {
+    const parsed = JSON.parse(
+      generatePiSettings({ provider: 'openrouter', model: 'deepseek/deepseek-v4-pro' }),
+    )
+    expect(parsed).toEqual({
+      defaultProvider: 'openrouter',
+      defaultModel: 'deepseek/deepseek-v4-pro',
+    })
+  })
+
+  it('ends with a newline like every other generator', () => {
+    expect(generatePiSettings({ provider: 'openrouter', model: 'm' })).toMatch(/\n$/)
+  })
+})
+
+describe('generateZooidYaml — pi (ZOD075)', () => {
+  it('emits acp preset pi', () => {
+    expect(generateZooidYaml({ preset: 'pi' })).toContain('acp: { preset: pi }')
+  })
+
+  // pi is the wizard's ONE pinned model (see registry.ts comment): its own
+  // default returned an empty turn. The pin lives in .pi-agent/settings.json,
+  // NOT in acp.model — acp.model is unwired for pi (ZOD073 non-goal).
+  it('does not pin the model via acp.model even when one is supplied', () => {
+    const yaml = generateZooidYaml({ preset: 'pi', model: 'deepseek/deepseek-v4-pro' })
+    expect(yaml).not.toContain('model: deepseek')
+  })
+})
+
+describe('generateGitignore — pi (ZOD075)', () => {
+  // .pi-agent holds settings and, on the shared-credential path, a link to a
+  // 600-mode token file. It must never be committable.
+  it('ignores the pi agent dir', () => {
+    expect(generateGitignore().split('\n')).toContain('.pi-agent/')
+  })
+
+  it('still ignores .env', () => {
+    expect(generateGitignore().split('\n')).toContain('.env')
+  })
+})

package/src/commands/init/generators.ts

@@ -1,18 +1,19 @@
 export interface ZooidYamlOpts {
-  preset: 'claude' | 'codex' | 'opencode'
+  preset: 'claude' | 'codex' | 'opencode' | 'pi'
   /**
    * 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.
+   * and pi read their own config files instead (opencode.json / settings.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.
+  // only) expands the block to carry it. pi is never expanded here — its pin
+  // lives in .pi-agent/settings.json; acp.model is unwired for pi (ZOD073).
   const acpBlock =
-    opts.preset === 'opencode' || !opts.model
+    opts.preset === 'opencode' || opts.preset === 'pi' || !opts.model
       ? `    acp: { preset: ${opts.preset} }`
       : `    acp:\n      preset: ${opts.preset}\n      model: ${opts.model}`
   return `runtime: local
@@ -125,7 +126,25 @@ export function generateEnv(opts: EnvOpts): string {
 }
 
 export function generateGitignore(): string {
-  return ['.env', 'node_modules/', 'data/', ''].join('\n')
+  // .pi-agent carries pi's settings and, on the shared-credential path, a link
+  // to a 600-mode token file. Never committable.
+  return ['.env', '.pi-agent/', 'node_modules/', 'data/', ''].join('\n')
+}
+
+export interface PiSettingsOpts {
+  provider: string
+  model: string
+}
+
+/**
+ * ZOD075. pi's *global* settings, relocated into the project by
+ * PI_CODING_AGENT_DIR. Only the two boot keys — theme and the rest stay the
+ * operator's business, and copying more would age badly.
+ */
+export function generatePiSettings(opts: PiSettingsOpts): string {
+  return (
+    JSON.stringify({ defaultProvider: opts.provider, defaultModel: opts.model }, null, 2) + '\n'
+  )
 }
 
 export function generateOpencodeReadme(): string {

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

@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, readFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { loadZooidConfig } from '@zooid/core'
+import { runInit } from '../init.js'
+
+let dir: string
+let fakeHome: string
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'zooid-pi-init-'))
+  fakeHome = mkdtempSync(join(tmpdir(), 'zooid-pi-home-'))
+  process.env.MATRIX_AS_TOKEN = 'as-test'
+  process.env.MATRIX_HS_TOKEN = 'hs-test'
+})
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true })
+  rmSync(fakeHome, { recursive: true, force: true })
+  delete process.env.MATRIX_AS_TOKEN
+  delete process.env.MATRIX_HS_TOKEN
+})
+
+const read = (p: string) => readFileSync(join(dir, p), 'utf8')
+
+describe('zooid init --preset pi (ZOD075)', () => {
+  it('scaffolds a config that parses and resolves the pi preset', async () => {
+    await runInit({ dir, preset: 'pi', auth: 'api-key', provider: 'openrouter', apiKey: 'sk-test', home: fakeHome })
+    const cfg = loadZooidConfig(read('zooid.yaml'))
+    expect(cfg.agents['zooid-assistant']!.acp).toMatchObject({ preset: 'pi' })
+  })
+
+  // The agent dir is RELATIVE so one value is correct under both runtimes:
+  // cwd is agents/zooid-assistant locally and /workspace in a container, and
+  // those are the same directory. See spike 1.1.
+  it('points PI_CODING_AGENT_DIR at a relative .pi-agent', () => {
+    expect(true).toBe(true) // asserted below once written
+  })
+
+  it('writes PI_CODING_AGENT_DIR into .env as a relative path', async () => {
+    await runInit({ dir, preset: 'pi', auth: 'api-key', provider: 'openrouter', apiKey: 'sk-test', home: fakeHome })
+    expect(read('.env')).toContain('PI_CODING_AGENT_DIR=.pi-agent')
+  })
+
+  it('writes the API key for the chosen provider', async () => {
+    await runInit({ dir, preset: 'pi', auth: 'api-key', provider: 'openrouter', apiKey: 'sk-test', home: fakeHome })
+    expect(read('.env')).toContain('OPENROUTER_API_KEY=sk-test')
+  })
+
+  // The settings file lands INSIDE the agent's workdir, because that is the
+  // cwd pi resolves the relative override against.
+  it('seeds .pi-agent/settings.json under the agent workdir', async () => {
+    await runInit({ dir, preset: 'pi', auth: 'api-key', provider: 'openrouter', apiKey: 'sk-test', home: fakeHome })
+    const s = JSON.parse(read('agents/zooid-assistant/.pi-agent/settings.json'))
+    expect(s).toEqual({
+      defaultProvider: 'openrouter',
+      defaultModel: 'deepseek/deepseek-v4-pro',
+    })
+  })
+
+  it('gitignores the agent dir', async () => {
+    await runInit({ dir, preset: 'pi', auth: 'api-key', provider: 'openrouter', apiKey: 'sk-test', home: fakeHome })
+    expect(read('.gitignore')).toContain('.pi-agent/')
+  })
+
+  it('writes AGENTS.md but no CLAUDE.md or opencode.json', async () => {
+    await runInit({ dir, preset: 'pi', auth: 'api-key', provider: 'openrouter', apiKey: 'sk-test', home: fakeHome })
+    expect(existsSync(join(dir, 'agents/zooid-assistant/AGENTS.md'))).toBe(true)
+    expect(existsSync(join(dir, 'agents/zooid-assistant/CLAUDE.md'))).toBe(false)
+    expect(existsSync(join(dir, 'agents/zooid-assistant/opencode.json'))).toBe(false)
+  })
+})
+
+describe('zooid init --preset pi auth choice (ZOD075)', () => {
+  const seedLogin = () => {
+    mkdirSync(join(fakeHome, '.pi', 'agent'), { recursive: true })
+    writeFileSync(join(fakeHome, '.pi', 'agent', 'auth.json'), '{"openrouter":{}}')
+  }
+
+  // The agent gets its OWN identity. This is the only path on a server, the
+  // simpler path in a container, and the right default when agent spend should
+  // be billed or revoked separately.
+  it('api-key gives the agent its own credential and shares nothing', async () => {
+    seedLogin()
+    await runInit({
+      dir, preset: 'pi', auth: 'api-key', provider: 'openrouter',
+      apiKey: 'sk-agent-own', home: fakeHome,
+    })
+    expect(read('.env')).toContain('OPENROUTER_API_KEY=sk-agent-own')
+    // No link/copy of the operator's auth.json anywhere in the scaffold.
+    expect(existsSync(join(dir, 'agents/zooid-assistant/.pi-agent/auth.json'))).toBe(false)
+  })
+
+  // Detecting a login must OFFER, never assume — an inferred share is exactly
+  // the silent guess this spec exists to remove.
+  it('does not borrow the login just because one was detected', async () => {
+    seedLogin()
+    await runInit({
+      dir, preset: 'pi', auth: 'api-key', provider: 'openrouter',
+      apiKey: 'sk-agent-own', home: fakeHome,
+    })
+    expect(existsSync(join(dir, 'agents/zooid-assistant/.pi-agent/auth.json'))).toBe(false)
+  })
+
+  it('requires --auth for pi, as it does for claude/codex', async () => {
+    await expect(
+      runInit({ dir, preset: 'pi', provider: 'openrouter', apiKey: 'k', home: fakeHome }),
+    ).rejects.toThrow(/--auth/)
+  })
+
+  it('rejects --auth subscription when no pi login exists', async () => {
+    await expect(
+      runInit({ dir, preset: 'pi', auth: 'subscription', home: fakeHome }),
+    ).rejects.toThrow(/no pi login/i)
+  })
+})
+
+describe('zooid init --preset pi inherits the operator settings (ZOD075)', () => {
+  const seedGlobal = (obj: unknown) => {
+    mkdirSync(join(fakeHome, '.pi', 'agent'), { recursive: true })
+    writeFileSync(join(fakeHome, '.pi', 'agent', 'settings.json'), JSON.stringify(obj))
+  }
+
+  // A pair the operator already runs is verified by use; prefer it to our pin.
+  it('prefers the global defaultProvider/defaultModel over the built-in pin', async () => {
+    seedGlobal({ defaultProvider: 'anthropic', defaultModel: 'claude-sonnet-5' })
+    await runInit({ dir, preset: 'pi', auth: 'api-key', provider: 'openrouter', apiKey: 'sk-test', home: fakeHome })
+    const s = JSON.parse(read('agents/zooid-assistant/.pi-agent/settings.json'))
+    expect(s).toEqual({ defaultProvider: 'anthropic', defaultModel: 'claude-sonnet-5' })
+  })
+
+  it('falls back to the pin when the global settings pin nothing', async () => {
+    seedGlobal({ theme: 'dark' })
+    await runInit({ dir, preset: 'pi', auth: 'api-key', provider: 'openrouter', apiKey: 'sk-test', home: fakeHome })
+    const s = JSON.parse(read('agents/zooid-assistant/.pi-agent/settings.json'))
+    expect(s.defaultProvider).toBe('openrouter')
+    expect(s.defaultModel).toBe('deepseek/deepseek-v4-pro')
+  })
+
+  // An explicit flag always wins over an inherited value.
+  it('lets --model override an inherited model', async () => {
+    seedGlobal({ defaultProvider: 'openrouter', defaultModel: 'deepseek/deepseek-v4-flash' })
+    await runInit({
+      dir, preset: 'pi', auth: 'api-key', provider: 'openrouter', apiKey: 'sk-test',
+      model: 'deepseek/deepseek-v4-pro', home: fakeHome,
+    })
+    const s = JSON.parse(read('agents/zooid-assistant/.pi-agent/settings.json'))
+    expect(s.defaultModel).toBe('deepseek/deepseek-v4-pro')
+  })
+})