@piagent/platform 1.7.1 → 1.9.0

package/scripts/piagent-dashboard.mjs

@@ -10,6 +10,7 @@ import { installedPiHostRoot } from "../packages/piagent-webui/gateway/pi-host.t
 import { gatewayProfileState, profileRef, readGatewayDescriptor, readOrCreateCatalogKey,
   removeGatewayDescriptor } from "../packages/piagent-webui/gateway/profile-state.ts";
 import { startPiagentGateway } from "../packages/piagent-webui/gateway/gateway-service.ts";
+import { agentWatchCompanyConnector } from "../packages/piagent-webui/gateway/managed-launch.ts";
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
@@ -111,9 +112,9 @@ async function control(action, timeoutMs = 1_500) {
   return await requestGatewayControl(state.controlSocket, { action }, timeoutMs);
 }
 
-async function currentLaunchUrl() {
+async function currentLaunchUrl(timeoutMs) {
   try {
-    const response = await control("issue-launch-url");
+    const response = await control("issue-launch-url", timeoutMs);
     if (response.ok && response.value && typeof response.value === "object"
       && typeof response.value.launchUrl === "string") return response.value.launchUrl;
   } catch {
@@ -122,6 +123,26 @@ async function currentLaunchUrl() {
   return null;
 }
 
+// A Gateway that is alive but busy answers late. Starting another one beside
+// it left two Gateways on the same conversations, the first unreachable and
+// still serving its pages, so the running one is waited for instead.
+async function waitForRunningGateway(timeoutMs = 30_000) {
+  const running = readGatewayDescriptor(gatewayProfileState(agentDir));
+  if (!running || !processAlive(running.pid)) return null;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline && processAlive(running.pid)) {
+    try {
+      const response = await control("issue-launch-url", 5_000);
+      if (response.ok && typeof response.value?.launchUrl === "string") return response.value.launchUrl;
+    } catch (error) {
+      // Nothing listens on its socket: the process is not a Gateway anymore.
+      if (!(error instanceof Error) || error.message !== "gateway-control-timeout") return null;
+    }
+  }
+  if (!processAlive(running.pid)) return null;
+  throw new Error("gateway-busy\nThe Gateway is running but did not answer within 30s. Try again, or run `piagent dashboard restart`.");
+}
+
 async function waitForGatewayStopped(previous, timeoutMs = 8_000) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -134,7 +155,7 @@ async function waitForGatewayStopped(previous, timeoutMs = 8_000) {
 }
 
 async function ensureStarted() {
-  const existing = await currentLaunchUrl();
+  const existing = await currentLaunchUrl() ?? await waitForRunningGateway();
   if (existing) return existing;
   const effectiveAgentDir = path.resolve(agentDir ?? process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent"));
   const state = gatewayProfileState(effectiveAgentDir);
@@ -168,7 +189,9 @@ async function ensureStarted() {
 }
 
 async function serve() {
-  const gateway = await startPiagentGateway({ packageRoot, expectedPiVersion, agentDir });
+  // Company sessions come from the Agent Watch binding in this Pi folder.
+  const piAgentDir = path.resolve(agentDir ?? process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent"));
+  const gateway = await startPiagentGateway({ packageRoot, expectedPiVersion, agentDir, company: agentWatchCompanyConnector(piAgentDir) });
   const shutdown = () => { void gateway.close(); };
   process.once("SIGINT", shutdown);
   process.once("SIGTERM", shutdown);

package/scripts/piagent-installations.mjs

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+
+// Read metadata only: never execute an old launcher (its Node/PATH may fail).
+export function piagentInstallations({home=os.homedir(), searchPath=process.env.PATH??'', systemRoots=['/opt/homebrew','/usr/local']}={}) {
+  const bins=new Set([...searchPath.split(path.delimiter).filter(Boolean),path.join(home,'.local/bin'),path.join(home,'.pi/npm-global/bin'),...systemRoots.map(root=>path.join(root,'bin'))]);
+  const found=new Map();
+  for(const bin of bins) {
+    try {
+      const launcher=fs.realpathSync(path.join(bin,'piagent'));
+      let root=path.dirname(launcher);
+      for(let depth=0;depth<5;depth++,root=path.dirname(root)) {
+        const manifest=path.join(root,'package.json');
+        if(!fs.existsSync(manifest))continue;
+        const pkg=JSON.parse(fs.readFileSync(manifest,'utf8'));
+        if(pkg.name!=='@piagent/platform')continue;
+        const managed=path.join(root,'scripts/piagent-studio.mjs');
+        const info=found.get(root)??{root,version:String(pkg.version),managed:fs.existsSync(managed),fingerprint:createHash('sha256').update(fs.readFileSync(fs.existsSync(managed)?managed:launcher)).digest('hex').slice(0,12),launchers:[]};
+        info.launchers.push(path.join(bin,'piagent'));found.set(root,info);break;
+      }
+    } catch { /* Missing/broken installation is not executed. */ }
+  }
+  return [...found.values()];
+}

package/scripts/piagent-studio.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { ManagedBrokerClient } from '../packages/piagent-core/managed/broker-client.mjs';
+import { ManagedSession } from '../packages/piagent-core/managed/session.mjs';
+import { resolveStore, storedSlot } from '../packages/piagent-core/managed/store.mjs';
+
+const digest = file => createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+// Node's experimental-feature notices (type stripping, SQLite) are not
+// actionable for members and bury the launch messages in Terminal.
+process.removeAllListeners('warning');
+process.on('warning', warning => { if (warning.name !== 'ExperimentalWarning') process.stderr.write(`${warning.name}: ${warning.message}\n`); });
+const args = process.argv.slice(2), flags = new Map();
+if (args.includes('--help')) { console.log('piagent studio [--web [--no-open] | --serve | --check | --doctor | --prompt <text>] [--config <Agent Watch configuration>] [--project <folder>]\nDefaults: the configuration imported into ~/.pi/agent and the current project. Personal sessions remain under pi / piagent dashboard.'); process.exit(0); }
+for (let i = 0; i < args.length; i++) {
+  if (['--check', '--doctor', '--web', '--serve', '--no-open'].includes(args[i])) { flags.set(args[i], true); continue; }
+  if (!['--config', '--project', '--prompt'].includes(args[i]) || flags.has(args[i]) || !args[i + 1]) throw Error('managed-launch-arguments');
+  flags.set(args[i], args[++i]);
+}
+const home = os.homedir();
+// Do this before importing the SDK: it must not discover personal keys, Node
+// preload hooks, proxy overrides or provider endpoints from an ambient shell.
+const clean = { PATH: '/usr/bin:/bin', HOME: home, LANG: 'en_US.UTF-8', TERM: process.env.TERM || 'xterm-256color' };
+for (const key of Object.keys(process.env)) delete process.env[key];
+Object.assign(process.env, clean);
+let broker, current, gateway, hold;
+try {
+  const configPath = fs.realpathSync(flags.get('--config') ?? path.join(home,'.pi/agent/agent-watch-managed.json'));
+  if (!fs.statSync(configPath).isFile() || fs.statSync(configPath).size > 16384) throw Error('managed-config-invalid');
+  const config = JSON.parse(fs.readFileSync(configPath));
+  // Agent Watch rewrites this when the key or its harness changes.
+  const bindingRevision = () => { try { return String(JSON.parse(fs.readFileSync(configPath, 'utf8')).configuration_revision ?? '') || null; } catch { return null; } };
+  // --serve backs the personal dashboard: no browser, no project of its own.
+  // Its startup probe runs in an empty private folder that is never listed.
+  const serve = flags.has('--serve');
+  if (serve && (flags.has('--project') || flags.has('--web') || flags.has('--check') || flags.has('--prompt'))) throw Error('managed-launch-arguments');
+  if (config.schema_version !== 1 || config.model !== 'agent-watch-auto' || !/^[a-f0-9]{64}$/.test(config.profile_id)
+    || config.entrypoint !== fs.realpathSync(fileURLToPath(import.meta.url)) || config.node !== fs.realpathSync(process.execPath)
+    || digest(config.entrypoint) !== config.entrypoint_sha256 || digest(config.node) !== config.node_sha256
+    || digest(config.broker) !== config.broker_sha256) throw Error('managed-launch-binding-changed');
+  // What company sessions need on this machine, checked with the real sandbox
+  // and broker; no conversation, no model request.
+  if (flags.has('--doctor')) {
+    const { runDoctor, doctorReport } = await import('../packages/piagent-core/managed/doctor.mjs');
+    const asked = new ManagedBrokerClient({ executable: config.broker, profileID: config.profile_id });
+    let report;
+    try { report = doctorReport(await runDoctor({ sdkRoot: config.sdk_root, origin: config.origin, broker: asked })); }
+    finally { await asked.dispose(); }
+    console.log(report.text); process.exit(report.ok ? 0 : 1);
+  }
+  // Conversations live in one store per member on this machine, whichever key
+  // Agent Watch holds: a key's slot learns its member once, then points there.
+  const root = path.join(home, 'Library/Application Support/AgentWatch/ManagedSessions');
+  let store = storedSlot(root, config.profile_id);
+  if (!store) {
+    const asked = new ManagedBrokerClient({ executable: config.broker, profileID: config.profile_id });
+    try { store = resolveStore(root, config.profile_id, { origin: config.origin, userId: (await asked.request('config'))?.user?.id }); }
+    finally { await asked.dispose(); }
+  }
+  const agentDir = path.join(root, store);
+  const cwd = serve ? path.join(agentDir, 'probe') : fs.realpathSync(flags.get('--project') || process.cwd());
+  if (configPath.startsWith(cwd + path.sep)) throw Error('managed-launch-binding-changed');
+  fs.mkdirSync(agentDir, { recursive: true, mode: 0o700 }); fs.chmodSync(agentDir, 0o700);
+  if (serve) { fs.mkdirSync(cwd, { recursive: true, mode: 0o700 }); fs.chmodSync(cwd, 0o700); }
+  await import('./register-typescript-loader.mjs');
+  if (flags.has('--web') || serve) {
+    if (flags.has('--check') || flags.has('--prompt')) throw Error('managed-launch-arguments');
+    const packageRoot=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+    const {requestGatewayControl}=await import('../packages/piagent-webui/gateway/control-socket.ts');
+    const {gatewayProfileState}=await import('../packages/piagent-webui/ownership/profile-state.ts');
+    const control=gatewayProfileState(agentDir).controlSocket;
+    const release=JSON.parse(fs.readFileSync(path.join(packageRoot,'package.json'),'utf8')).version;
+    const health=async()=>{ try { const reply=await requestGatewayControl(control,{action:'health'}); return reply.ok ? reply.value ?? {} : null; } catch { return null; } };
+    // This key's company Gateway may already run: the dashboard starts one and
+    // an earlier WebUI launch may still be open. Reuse it when it is this
+    // release (a new browser session on this project); replace an older one.
+    let running=await health();
+    for(const started=Date.now();running && !running.packageVersion && running.state==='starting' && Date.now()-started<45000;running=await health()) await new Promise(r=>setTimeout(r,250));
+    if(running && running.packageVersion!==release){
+      try { await requestGatewayControl(control,{action:'stop'}); } catch {}
+      for(const started=Date.now();await health();) { if(Date.now()-started>15000) throw Error('managed-launch-stale-runtime'); await new Promise(r=>setTimeout(r,250)); }
+      running=null;
+    }
+    if(!running){
+      const {startManagedGateway}=await import('../packages/piagent-webui/gateway/managed-gateway.mjs');
+      gateway=await startManagedGateway({config,configPath,cwd,agentDir,registerProject:!serve,packageRoot});
+    }
+    if (serve) process.stdout.write('Agent Watch Auto: ready\n');
+    else {
+      // Register (idempotent) to learn the project's ref: the page opens a new
+      // conversation for the project chosen in Agent Watch.
+      const registered=await requestGatewayControl(control,{action:'project.register',cwd});
+      if(!registered.ok || typeof registered.value?.projectRef!=='string') throw Error('managed-web-launch-failed');
+      const result=await requestGatewayControl(control,{action:'issue-launch-url'});
+      if(!result.ok || !result.value?.launchUrl) throw Error('managed-web-launch-failed');
+      result.value.launchUrl+=`&project=${encodeURIComponent(registered.value.projectRef)}`;
+      process.stdout.write(`Agent Watch Auto: ${result.value.launchUrl}\n`);
+      if(!flags.has('--no-open')){ const {spawn}=await import('node:child_process'); spawn('/usr/bin/open',[result.value.launchUrl],{stdio:'ignore',env:clean}).unref(); }
+    }
+    if(gateway){
+      process.once('SIGINT',()=>void gateway.close());process.once('SIGTERM',()=>void gateway.close());
+      await gateway.wait();
+    } else if(!serve) process.stdout.write('Agent Watch Auto: opened in the running company session service; closing this window does not stop it.\n');
+  } else {
+  // The key Agent Watch holds now: a conversation that enrolls again follows it.
+  const slot = () => { try { const now = JSON.parse(fs.readFileSync(configPath, 'utf8')); return /^[a-f0-9]{64}$/.test(now.profile_id) && now.broker === config.broker ? now.profile_id : config.profile_id; } catch { return config.profile_id; } };
+  const newBroker = () => new ManagedBrokerClient({ executable: config.broker, profileID: slot() });
+  broker = newBroker();
+  const api = await import(pathToFileURL(path.join(config.sdk_root, 'dist/index.js')));
+  // The conversation this process writes is held in the same lease the
+  // company Gateway uses: the WebUI shows it running here and never runs it
+  // at the same time. One the WebUI is running is refused.
+  const { holdManagedSession } = await import('../packages/piagent-webui/ownership/managed-terminal-lease.ts');
+  const factory = async ({ cwd, sessionManager }) => {
+    let next;
+    try { next = holdManagedSession(agentDir, sessionManager.getSessionFile()); }
+    catch (error) { throw Error(String(error?.message) === 'session-owner-conflict' ? 'managed-session-open-elsewhere' : 'managed-session-lease-unavailable'); }
+    hold?.release(); hold = next;
+    // A conversation that enrolled again (key or harness changed) holds the live broker.
+    if (current) { broker = current.broker; await current.session.abort(); await Promise.allSettled([...current.helpers.values()]); await broker.request('close'); current.session.dispose(); await current.boundary.dispose(); }
+    current = await ManagedSession.create({ sdkRoot: config.sdk_root, cwd, origin: config.origin, broker, agentDir, sessionManager,
+      protectedRoots: [configPath, agentDir], renewBroker: newBroker, bindingRevision });
+    return { session: current.session, extensionsResult: current.extensionsResult, services: current.services, diagnostics: [] };
+  };
+  const host = await api.createAgentSessionRuntime(factory, { cwd, agentDir, sessionManager: api.SessionManager.create(cwd, path.join(agentDir, 'sessions')) });
+  if (flags.get('--check')) console.log('agent-watch-auto: connected; native context; isolated tools; no inference sent.');
+  else if (flags.has('--prompt')) {
+    current.session.subscribe(event => {
+      if (event.type === 'message_update' && event.assistantMessageEvent.type === 'text_delta') process.stdout.write(event.assistantMessageEvent.delta);
+      if (event.type === 'message_end' && ['agent-watch-helper-receipt','agent-watch-review-status'].includes(event.message?.customType)) process.stderr.write(String(event.message.content) + '\n');
+    });
+    await current.session.prompt(flags.get('--prompt')); process.stdout.write('\n');
+    const last=current.session.messages.filter(message=>message.role==='assistant').at(-1);
+    if (last?.stopReason === 'error') {
+      // Already says who failed and why, ending in its stable [code].
+      process.stderr.write(`${String(last.errorMessage??'Agent Watch: the request failed [managed-request-failed]')}\n`);process.exitCode = 1;
+    }
+  } else {
+    // The company terminal runs the pinned Pi release: no "Run pi update" notice
+    // (updating Pi breaks the Agent Watch import), no package-update, catalog or
+    // install-telemetry calls. Search tools were provisioned above.
+    process.env.PI_OFFLINE = '1'; process.env.PI_SKIP_VERSION_CHECK = '1';
+    await new api.InteractiveMode(host, { verbose: false }).run();
+  }
+  }
+} catch (error) {
+  // Never print JSON payloads or startup objects that can contain role tokens.
+  const code = error instanceof Error && /^managed-[a-z:_-]+$/.test(error.message) ? error.message : 'managed-launch-failed';
+  const hint = code === 'managed-session-open-elsewhere' ? 'This conversation is running in the Piagent WebUI; continue it there, or start a new one here.'
+    : 'Refresh the Studio import or check Keychain access.';
+  process.stderr.write(`Agent Watch: ${code}. ${hint}\n`); process.exitCode = 1;
+} finally { await gateway?.close(); if (current) await current.dispose(); else await broker?.dispose(); hold?.release(); }

package/scripts/runtime-advisory-exceptions.json

@@ -0,0 +1,29 @@
+{
+  "version": 1,
+  "exceptions": [
+    {
+      "id": "GHSA-q2hr-2g5m-vwhr",
+      "package": "brace-expansion",
+      "node": "node_modules/@earendil-works/pi-coding-agent/node_modules/brace-expansion",
+      "decided": "2026-10-02",
+      "until": "2026-10-31",
+      "reason": "Denial of service (CPU) through a crafted brace pattern in a glob; no data exposure. brace-expansion 5.0.9 is pinned by the npm-shrinkwrap of every published Pi host (0.87.1 to 1.0.0), so no Piagent change can update it; 5.0.12 fixes it. Remove when a Pi host carries brace-expansion >= 5.0.12."
+    },
+    {
+      "id": "GHSA-qhr7-859c-m2p7",
+      "package": "brace-expansion",
+      "node": "node_modules/@earendil-works/pi-coding-agent/node_modules/brace-expansion",
+      "decided": "2026-10-02",
+      "until": "2026-10-31",
+      "reason": "Denial of service (stack exhaustion) through nested brace groups in a glob; no data exposure. Pinned by the Pi host's npm-shrinkwrap as above; fixed in 5.0.11."
+    },
+    {
+      "id": "GHSA-6j4f-fj2g-mc7p",
+      "package": "brace-expansion",
+      "node": "node_modules/@earendil-works/pi-coding-agent/node_modules/brace-expansion",
+      "decided": "2026-10-02",
+      "until": "2026-10-31",
+      "reason": "Denial of service (stack exhaustion) in parseCommaParts; no data exposure. Pinned by the Pi host's npm-shrinkwrap as above; fixed in 5.0.10."
+    }
+  ]
+}

package/scripts/setup.sh

@@ -36,7 +36,7 @@ Options:
   --model-scope <full|codex|claude>   model families to enable
                                   Configure Pi enabledModels for selector/cycling (default: full)
   --default-model <provider/model[:thinking]>
-                                  Configure default provider/model/thinking (default: openai-codex/gpt-5.6-sol:high)
+                                  Configure default provider/model/thinking (default: openai-codex/gpt-6-sol:high)
   --no-model-scope               Skip global model-scope configuration
   --install-pi / --no-install-pi Install/skip Pi CLI with npm if `pi` is missing (default: install)
   --force-profile                Replace existing project .pi/piagent-profile.json
@@ -78,7 +78,7 @@ WITH_WEB_ACCESS=true
 WITH_HERDR=true
 CONFIGURE_MODEL_SCOPE=true
 MODEL_SCOPE_PRESET="full"
-DEFAULT_MODEL="openai-codex/gpt-5.6-sol:high"
+DEFAULT_MODEL="openai-codex/gpt-6-sol:high"
 AUTO_INSTALL_PI=true
 FORCE_PROFILE=false
 FORCE_SETTINGS=false

package/scripts/team-doctor.sh

@@ -67,6 +67,9 @@ const strictShare = strictShareRaw === "true";
 const offline = offlineRaw === "true";
 const errors = [];
 const warnings = [];
+const { piagentInstallations } = await import(pathToFileURL(path.join(platformRoot, "scripts/piagent-installations.mjs")).href);
+const installations = piagentInstallations();
+if(installations.length>1) warnings.push("Multiple Piagent installations detected. Use the pinned Watch launcher; other PATHs may run an older build: "+installations.map(i=>`${i.version} [${i.fingerprint}] ${i.root}`).join("; "));
 const { verifyCapabilityLock } = await import(pathToFileURL(path.join(platformRoot, "packages", "piagent-core", "capabilities", "capability-core.js")).href);
 
 function exists(rel) {
@@ -185,7 +188,7 @@ for (const rel of [
 const rootPackage = readJson(path.join(platformRoot, "package.json"));
 if (!rootPackage.pi?.extensions?.length) errors.push("root package.json missing pi.extensions");
 if (!rootPackage.pi?.skills?.length) errors.push("root package.json missing pi.skills");
-if (!rootPackage.pi?.prompts?.length) errors.push("root package.json missing pi.prompts");
+// Prompt templates are optional: freeform chat does not require workflow prompts.
 if (!rootPackage.pi?.subagents?.agents?.length) errors.push("root package.json missing pi.subagents.agents");
 
 if (!commandExists("pi")) warnings.push("pi is not on PATH");
@@ -297,6 +300,20 @@ try {
   warnings.push(`MCP readiness check could not run: ${error instanceof Error ? error.message : String(error)}`);
 }
 
+// A pattern in enabledModels that matches no model Pi knows makes Pi print a
+// warning on every start; it never matches again by itself.
+try {
+  const prune = await import(pathToFileURL(path.join(platformRoot, "scripts", "model-scope-prune.mjs")).href);
+  const agentDir = process.env.PI_CODING_AGENT_DIR || path.join(process.env.HOME || "", ".pi", "agent");
+  const settings = readJsonIfPresent(path.join(agentDir, "settings.json"));
+  const patterns = Array.isArray(settings?.enabledModels) ? settings.enabledModels.filter((item) => typeof item === "string") : [];
+  const piRoot = patterns.length ? prune.piPackageRoot() : null;
+  const stale = piRoot ? await prune.stalePatterns(patterns, await prune.knownModels(piRoot, agentDir), piRoot) : [];
+  if (stale.length) warnings.push(`Pi enabledModels has ${stale.length} pattern(s) that match no model Pi knows (${stale.join(", ")}); Pi warns about them on every start. Run \`piagent-model-scope --prune\` to remove only these`);
+} catch (error) {
+  warnings.push(`model scope check could not run: ${error instanceof Error ? error.message : String(error)}`);
+}
+
 const subagentConfigPath = path.join(process.env.PI_CODING_AGENT_DIR || path.join(process.env.HOME || "", ".pi", "agent"), "extensions", "subagent", "config.json");
 const subagentConfig = readJsonIfPresent(subagentConfigPath);
 if (piHasSubagents && !subagentConfig) {
@@ -541,6 +558,8 @@ const report = {
   },
   rootPiManifest: rootPackage.pi,
   warnings,
+  installations,
+  nodeExecutable: process.execPath,
   errors
 };
 

package/scripts/typescript-loader.mjs

@@ -5,6 +5,12 @@ import { stripTypeScriptTypes } from "node:module";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
+// This runs on Node's loader thread, where a launcher's warning filter does
+// not apply: hide only the experimental notice for type stripping, which
+// members cannot act on (`piagent studio` from Agent Watch runs plain node).
+process.removeAllListeners("warning");
+process.on("warning", (warning) => { if (warning.name !== "ExperimentalWarning") process.stderr.write(`${warning.name}: ${warning.message}\n`); });
+
 const BENCHMARK_BOOTSTRAP_METADATA = "PIAGENT_BENCHMARK_BOOTSTRAP_METADATA";
 const RUNTIME_DEPENDENCY_KEYS = [
   "schemaVersion", "node", "platform", "packages", "resolutionRoot", "resolutionTree", "isolation", "digest"

package/scripts/verify-local.sh

@@ -634,15 +634,15 @@ for (const rel of jsonFiles) {
 }
 
 const rootPkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
-if (!rootPkg.pi || !rootPkg.pi.extensions || !rootPkg.pi.prompts || !rootPkg.pi.skills) {
+if (!rootPkg.pi || !rootPkg.pi.extensions || !rootPkg.pi.skills) {
   throw new Error("root package.json missing pi manifest");
 }
 if (!rootPkg.pi.subagents?.agents?.length) {
   throw new Error("root package.json missing pi.subagents.agents");
 }
 const expectedPeers = {
-  "@earendil-works/pi-ai": "0.86.1",
-  "@earendil-works/pi-coding-agent": "0.86.1",
+  "@earendil-works/pi-ai": "0.87.1",
+  "@earendil-works/pi-coding-agent": "0.87.1",
   typebox: "1.3.27"
 };
 for (const [name, version] of Object.entries(expectedPeers)) {
@@ -651,7 +651,7 @@ for (const [name, version] of Object.entries(expectedPeers)) {
 }
 
 const pkg = JSON.parse(fs.readFileSync(path.join(root, "packages/piagent-core/package.json"), "utf8"));
-if (!pkg.pi || !pkg.pi.extensions || !pkg.pi.prompts || !pkg.pi.skills) {
+if (!pkg.pi || !pkg.pi.extensions || !pkg.pi.skills) {
   throw new Error("packages/piagent-core/package.json missing pi manifest");
 }
 if (!pkg.pi.subagents?.agents?.length) {
@@ -945,7 +945,7 @@ if [[ "$OFFLINE" == true || "${PIAGENT_VERIFY_OFFLINE:-}" == "1" || "${CI:-}" ==
 else
   bash "$ROOT/scripts/pi-model-catalog.sh" --json >/dev/null
 fi
-bash "$ROOT/scripts/configure-model-scope.sh" --dry-run --preset full --default-model openai-codex/gpt-5.6-sol:high >/dev/null
+bash "$ROOT/scripts/configure-model-scope.sh" --dry-run --preset full --default-model openai-codex/gpt-6-sol:high >/dev/null
 node "$ROOT/scripts/mcp-manage.mjs" --list >/dev/null
 node "$ROOT/scripts/mcp-manage.mjs" --dry-run --preset popular --scope project --project "$ROOT" >/dev/null
 node --input-type=module - "$ROOT" <<'NODE'

package/scripts/verify-release-identity.mjs

@@ -58,7 +58,7 @@ const packageLock = readJson("package-lock.json");
 const capabilityLock = readJson(".pi/piagent-profile.lock.json");
 const version = rootPackage.version;
 const expectedTag = `v${version}`;
-const supportedPiHost = "0.86.1";
+const supportedPiHost = "0.87.1";
 
 // The package is published now, so the old private-forever rule is gone. What
 // still has to hold is that a scoped package cannot reach the registry as

package/templates/global/settings.json

@@ -1,7 +1,7 @@
 {
   "defaultProjectTrust": "ask",
   "defaultProvider": "openai-codex",
-  "defaultModel": "gpt-5.6-sol",
+  "defaultModel": "gpt-6-sol",
   "defaultThinkingLevel": "high",
   "showCacheMissNotices": true,
   "enabledModels": [
@@ -12,6 +12,10 @@
     "openai-codex/gpt-5.6-luna:medium",
     "openai-codex/gpt-5.6-terra:high",
     "openai-codex/gpt-5.6-sol:high",
+    "openai-codex/gpt-6-luna:medium",
+    "openai-codex/gpt-6-sol:medium",
+    "openai-codex/gpt-6-sol:high",
+    "openai-codex/gpt-6-astra:xhigh",
     "openai-codex/*",
     "anthropic/claude-haiku-4-5:low",
     "anthropic/claude-sonnet-4-5:high",
@@ -21,7 +25,9 @@
     "anthropic/claude-opus-4-6:max",
     "anthropic/claude-opus-4-7:xhigh",
     "anthropic/claude-opus-4-8:xhigh",
-    "anthropic/claude-fable-5:xhigh"
+    "anthropic/claude-fable-5:xhigh",
+    "anthropic/claude-sonnet-5-5:high",
+    "anthropic/claude-opus-5-5:high"
   ],
   "compaction": {
     "enabled": true,

package/templates/project/.pi/project-context.md

@@ -4,7 +4,7 @@
 
 - Generated: not yet
 - Profile: see `.pi/piagent-profile.json`
-- Model/pass: run `/onboard run` after Pi login and model selection
+- Model/pass: ask the agent to onboard the project after Pi login and model selection
 - Scope: pending
 
 ## Purpose
@@ -16,13 +16,13 @@ Before the first real implementation task in this project:
 1. Open Pi in the project.
 2. Run `/login` if needed.
 3. Select the intended provider/model.
-4. Run `/onboard run`.
+4. Ask the agent: "Inspect this project read-only and record its project context."
 
 The selected model should inspect the project read-only, then replace this file with a concise project map, required context, verification matrix, and high-risk areas.
 
 ## Update triggers
 
-Regenerate with `/onboard run` when:
+Ask the agent to refresh it when:
 
 - source layout changes;
 - architecture or domain ownership changes;

package/templates/project/AGENTS.md

@@ -7,12 +7,11 @@ This project uses Pi Agent Platform.
 
 For an ordinary source task:
 
-1. Runtime binds bounded source work to this Pi session before the model starts. If intake pauses for broad/high-risk/ambiguous scope, call `piagent_task_start` exactly once with project-relative path/glob scope and reuse the contract.
-2. Read the narrow target and nearest test. Use ordinary read/search/edit/bash tools and one writer.
-3. Complete intended source and focused regression-test edits, then run each exact runtime verifier. Rerun only after another mutation.
-4. Do not call Piagent management/diagnostic tools unless runtime or the operator asks. Report changed files, verification, and residual risk concisely.
+1. Read the narrow target and nearest test. Use ordinary read/search/edit/bash tools and one writer.
+2. Make the change, then run the project's checks. Rerun only after another change.
+3. Do not call Piagent management/diagnostic tools unless runtime or the operator asks. Report changed files, verification, and residual risk concisely.
 
-Runtime enforces protected paths, permissions, external/destructive confirmation, scope, current-tree evidence, and the final gate. Current source is authoritative; generated context is advisory. Use subagents only for independent read-only lanes.
+Runtime enforces protected paths, permissions, read-only paths, and external/destructive confirmation. Current source is authoritative; generated context is advisory. Use subagents only for independent read-only lanes.
 <!-- piagent-managed:end -->
 
 ## Review