zooid 0.11.2 → 0.12.0

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zooid",
-  "version": "0.11.2",
+  "version": "0.12.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",
@@ -41,13 +41,13 @@
     "sanitize-html": "^2.17.4",
     "tar": "^7.5.16",
     "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/context-mcp": "^0.12.0",
+    "@zooid/acp-client": "^0.12.0",
+    "@zooid/core": "^0.12.0",
+    "@zooid/runtime-docker": "^0.12.0",
+    "@zooid/transport-http": "^0.12.0",
+    "@zooid/runtime-local": "^0.12.0",
+    "@zooid/transport-matrix": "^0.12.0"
   },
   "devDependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",

package/src/bin.ts

@@ -87,10 +87,10 @@ 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')

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/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')
+  })
+})

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()
+  })
+})