pi-pstack-native 0.0.0-stage → 1.0.0

package/test/setup-command.test.ts

@@ -0,0 +1,212 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import extension from '../src/extension.ts';
+import { loadModels, saveModels } from '../src/runtime/config.ts';
+
+const claude = { provider: 'anthropic', id: 'claude-opus-4', reasoning: true, thinkingLevelMap: { xhigh: 'high', max: 'high' } };
+const grok = { provider: 'xai', id: 'grok-4', reasoning: true, thinkingLevelMap: { xhigh: 'high', max: 'high' } };
+const claudeId = 'anthropic/claude-opus-4', grokId = 'xai/grok-4';
+type Choose = (title: string, options: string[], call: number) => string | undefined;
+
+async function setup(choose: Choose, models: any[] = [claude, grok], parent: any = claude, registryModels = models, scopedModels: any[] = []) {
+  const commands = new Map<string, any>(), messages: Array<{ text: string; options: any }> = [];
+  extension({ registerCommand: (name: string, value: any) => commands.set(name, value), registerTool() {}, on() {}, sendUserMessage: (text: string, options: any) => messages.push({ text, options }) } as any);
+  const notices: string[] = [], titles: string[] = [], optionLists: string[][] = [];
+  const ctx = {
+    hasUI: true, model: parent, scopedModels, isIdle: () => true,
+    modelRegistry: { getAvailable: () => models, find: (provider: string, id: string) => registryModels.find(m => m.provider === provider && m.id === id) },
+    ui: { select: (title: string, options: string[]) => { titles.push(title); optionLists.push(options); assert(titles.length < 100, 'wizard must make progress'); return choose(title, options, titles.length); }, notify: (message: string) => notices.push(message) },
+  };
+  await commands.get('setup-pstack').handler('', ctx);
+  return { notices, titles, optionLists, messages };
+}
+async function withHome(fn: (home: string) => Promise<void>) {
+  const old = process.env.PSTACK_NATIVE_HOME, home = mkdtempSync(join(tmpdir(), 'pstack-setup-'));
+  process.env.PSTACK_NATIVE_HOME = home;
+  try { await fn(home); } finally { if (old === undefined) delete process.env.PSTACK_NATIVE_HOME; else process.env.PSTACK_NATIVE_HOME = old; rmSync(home, { recursive: true, force: true }); }
+}
+const save: Choose = (title, options) => title.startsWith('Child reasoning') ? options[0] : options.includes('Save settings') ? 'Save settings' : undefined;
+
+test('fresh setup defaults to the upstream large budget, previews all mappings in pages, and offers verification through the agent', async () => withHome(async () => {
+  const { notices, titles, optionLists, messages } = await setup((title, options) => {
+    if (title.startsWith('Child reasoning')) { assert.equal(options[0], 'large — xhigh reasoning'); assert(options.includes('Cancel setup')); return options[0]; }
+    return options.includes('Next page →') ? 'Next page →' : 'Save settings';
+  });
+  const all = titles.join('\n');
+  for (const text of ['Role worker: xai/grok-4', 'feature: role default (xai/grok-4)', 'how explainer:', 'swarm workers:', 'arena runners 1:', 'arena cross-judge pool 1:', 'architect runners 2:', 'interrogate reviewers 2:']) assert(all.includes(text), text);
+  assert(all.includes('Pi maps xhigh to high'));
+  assert(optionLists.every(options => options.length <= 8));
+  const config = loadModels();
+  assert.equal(config.thinkingLevel, 'xhigh');
+  assert.equal(config.roles.worker, grokId);
+  assert.deepEqual(config.panels?.interrogate, [claudeId, grokId]);
+  assert.equal(config.workflows?.reflect.tooling, grokId);
+  assert.match(notices.at(-1)!, /Saved pstack settings/);
+  assert.equal(messages.length, 1);
+  assert.match(messages[0]!.text, /existing harness.*not merely unit tests/);
+  assert.match(messages[0]!.text, /ask and wait for the user's answer/);
+  assert.match(messages[0]!.text, /create-formal-verification-skill/);
+  assert.equal(messages[0]!.options.expandPromptTemplates, true);
+}));
+
+test('rerun keeps the current budget, aliases, panel order, custom mappings and unknown metadata', async () => withHome(async home => {
+  const path = join(home, 'models.json');
+  writeFileSync(path, JSON.stringify({ version: 1, thinkingLevel: 'max', fallbackPolicy: 'disabled', roles: { worker: 'auto', custom: grokId }, workflows: { feature: { worker: 'auto' }, custom: { worker: claudeId } }, panels: { arena: ['auto', claudeId], extra: [grokId] }, metadata: { keep: true } }));
+  const result = await setup((title, options) => {
+    if (title.startsWith('Child reasoning')) { assert.match(title, /current: max/); assert.equal(options[0], 'unlimited — max reasoning'); return options[0]; }
+    return 'Save settings';
+  });
+  const config = loadModels();
+  assert.equal(config.thinkingLevel, 'max');
+  assert.equal(config.roles.worker, 'auto');
+  assert.deepEqual(config.panels?.arena, ['auto', claudeId]);
+  assert.equal(config.workflows?.custom.worker, claudeId);
+  assert.deepEqual(JSON.parse(readFileSync(path, 'utf8')).metadata, { keep: true });
+  assert(result.notices.some(notice => /Repeated seats.*arena/.test(notice)));
+}));
+
+test('unavailable models cannot be saved even with inherited reasoning and can be repaired in the same wizard', async () => withHome(async () => {
+  saveModels({ version: 1, thinkingLevel: 'inherit-parent', roles: { worker: 'old/missing' } });
+  let attempted = false, edited = false;
+  const result = await setup((title, options) => {
+    if (title.startsWith('Child reasoning')) return options[0];
+    if (title.startsWith('Review pstack settings')) {
+      if (!attempted) { attempted = true; return 'Save settings'; }
+      if (!edited) { edited = true; assert.match(title, /needs choice: not available/); return 'Edit a role'; }
+      return 'Save settings';
+    }
+    if (title.startsWith('Choose role')) return options.find(x => x.startsWith('worker —'));
+    if (title.startsWith('Model for worker')) return options.find(x => x.startsWith('auto —'));
+    return undefined;
+  }, [claude], claude, [claude, { provider: 'old', id: 'missing', reasoning: true }]);
+  assert(result.notices.some(notice => /Cannot save yet.*not available/.test(notice)));
+  assert.equal(loadModels().roles.worker, 'auto');
+  assert.equal(result.messages.length, 1);
+}));
+
+test('unsupported reasoning can be corrected without discarding model choices', async () => withHome(async () => {
+  const basic = { provider: 'a', id: 'basic', reasoning: false };
+  let attempt = 0;
+  const result = await setup((title, options) => {
+    if (title.startsWith('Child reasoning')) {
+      if (attempt === 0) return options.find(x => x.startsWith('unlimited'));
+      return options.find(x => x.startsWith('off —')) ?? 'Next page →';
+    }
+    if (title.startsWith('Review pstack')) return ++attempt === 1 ? 'Save settings' : attempt === 2 ? 'Change budget' : 'Save settings';
+    return undefined;
+  }, [basic], basic);
+  assert(result.notices.some(notice => /does not support max/.test(notice)));
+  assert.equal(loadModels().thinkingLevel, 'off');
+  assert.equal(loadModels().roles.worker, 'a/basic');
+}));
+
+test('edit one panel seat and preserve the rest and the feature/refactoring overrides', async () => withHome(async () => {
+  saveModels({ version: 1, thinkingLevel: 'inherit-parent', roles: {}, workflows: { feature: { worker: claudeId }, refactoring: { worker: grokId } }, panels: { arena: [claudeId, grokId], extra: [grokId] } });
+  let step = 0;
+  await setup((title, options) => {
+    if (title.startsWith('Child reasoning')) return options[0];
+    if (title.startsWith('Review pstack')) return step++ === 0 ? 'Edit a panel' : 'Save settings';
+    if (title.startsWith('Choose panel')) return options.find(x => x.startsWith('arena runners'));
+    if (title.startsWith('arena runners')) return step === 1 ? (step++, options.find(x => x.startsWith('Seat 2:'))) : 'Done editing panel';
+    if (title.startsWith('Seat 2:')) return 'Change model';
+    if (title.startsWith('Model for arena runners')) return options.find(x => x.startsWith('auto —'));
+    return undefined;
+  });
+  const config = loadModels();
+  assert.deepEqual(config.panels?.arena, [claudeId, 'auto']);
+  assert.deepEqual(config.panels?.extra, [grokId]);
+  assert.equal(config.workflows?.feature.worker, claudeId);
+  assert.equal(config.workflows?.refactoring.worker, grokId);
+}));
+
+test('long model registries are paginated and the suggested judge pool is bounded', async () => withHome(async () => {
+  const models = Array.from({ length: 30 }, (_, i) => ({ provider: 'p', id: `model-${String(i).padStart(2, '0')}`, reasoning: true, thinkingLevelMap: { xhigh: 'high' } }));
+  let edit = true;
+  const result = await setup((title, options) => {
+    if (title.startsWith('Child reasoning')) return options[0];
+    if (title.startsWith('Review pstack')) { if (edit) { edit = false; return 'Edit a role'; } return 'Save settings'; }
+    if (title.startsWith('Choose role')) return options.find(x => x.startsWith('worker —'));
+    if (title.startsWith('Model for worker')) return options.find(x => x === 'p/model-13') ?? 'Next page →';
+    return undefined;
+  }, models, models[0]);
+  assert.equal(loadModels().roles.worker, 'p/model-13');
+  assert((loadModels().panels?.['arena-judges']?.length ?? 0) <= 16);
+  assert(result.titles.filter(t => t.startsWith('Model for worker')).length > 2);
+  assert(result.optionLists.every(options => options.length <= 8));
+}));
+
+test('editing feature leaves a separately customized refactoring model untouched', async () => withHome(async () => {
+  saveModels({ version: 1, thinkingLevel: 'inherit-parent', roles: {}, workflows: { feature: { worker: claudeId }, refactoring: { worker: grokId } } });
+  let edited = false;
+  await setup((title, options) => {
+    if (title.startsWith('Child reasoning')) return options[0];
+    if (title.startsWith('Review pstack')) { if (!edited) { edited = true; return 'Edit a task model'; } return 'Save settings'; }
+    if (title.startsWith('Choose task model')) return options.find(x => x.startsWith('feature —'));
+    if (title.startsWith('Model for feature')) return options.find(x => x.startsWith('auto —'));
+    return undefined;
+  });
+  const config = loadModels();
+  assert.equal(config.workflows?.feature.worker, 'auto');
+  assert.equal(config.workflows?.refactoring.worker, grokId);
+}));
+
+test('availability is rechecked immediately before saving', async () => withHome(async home => {
+  const models = [claude, grok];
+  let attempted = false;
+  const result = await setup((title, options) => {
+    if (title.startsWith('Child reasoning')) return options[0];
+    if (!attempted) { attempted = true; models.splice(0, models.length); return 'Save settings'; }
+    return undefined;
+  }, models, claude);
+  assert(result.notices.some(notice => /Cannot save yet.*not available/.test(notice)));
+  assert.throws(() => readFileSync(join(home, 'models.json'), 'utf8'), { code: 'ENOENT' });
+  assert.equal(result.messages.length, 0);
+}));
+
+test('cancel, malformed input, and concurrent edits never overwrite existing settings', async () => withHome(async home => {
+  const path = join(home, 'models.json');
+  saveModels({ version: 1, thinkingLevel: 'off', roles: { worker: 'auto' } });
+  const before = readFileSync(path, 'utf8');
+  for (let stop = 1; stop <= 4; stop++) {
+    const result = await setup((title, options, call) => {
+      if (call === stop) return undefined;
+      if (title.startsWith('Review pstack')) return 'Edit a role';
+      return options[0];
+    });
+    assert.match(result.notices.at(-1)!, /cancelled/);
+    assert.equal(readFileSync(path, 'utf8'), before);
+    assert.equal(result.messages.length, 0);
+  }
+  writeFileSync(path, '{broken');
+  const corrupt = await setup(save);
+  assert.match(corrupt.notices.at(-1)!, /invalid JSON/);
+  assert.equal(readFileSync(path, 'utf8'), '{broken');
+  writeFileSync(path, before);
+  const concurrent = await setup((title, options) => {
+    if (title.startsWith('Child reasoning')) return options[0];
+    writeFileSync(path, `${before} `);
+    return 'Save settings';
+  });
+  assert.match(concurrent.notices.at(-1)!, /changed during setup/);
+  assert.equal(readFileSync(path, 'utf8'), `${before} `);
+  assert.equal(concurrent.messages.length, 0);
+}));
+
+test('no detected models permits parent aliases and does not start a model turn without a parent', async () => withHome(async () => {
+  const result = await setup(save, [], null);
+  assert(result.notices.some(notice => /No available Pi models detected/.test(notice)));
+  assert.equal(loadModels().roles.worker, 'inherit-parent');
+  assert.equal(result.messages.length, 0);
+}));
+
+test('pstack-runtime reports the manifest version instead of a hardcoded one', async () => {
+  const commands = new Map<string, any>(), notices: string[] = [];
+  extension({ registerCommand: (name: string, value: any) => commands.set(name, value), registerTool() {}, on() {}, sendUserMessage() {} } as any);
+  await commands.get('pstack-runtime').handler('', { ui: { notify: (message: string) => notices.push(message) } });
+  const manifest = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+  assert.match(notices[0]!, new RegExp(`^pi-pstack-native ${manifest.version.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\n`));
+  assert.doesNotMatch(notices[0]!, /npm: 2333/);
+});

package/test/setup-rpc.test.ts

@@ -0,0 +1,68 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { startModelServer, writeModelConfig } from './e2e/harness.ts';
+
+test('real Pi RPC runs setup and dispatches the optional verification follow-up', { timeout: 40_000 }, async () => {
+  const root = process.cwd();
+  const dir = mkdtempSync(join(tmpdir(), 'pstack-setup-rpc-'));
+  const agentDir = join(dir, 'agent'), home = join(dir, 'home'), project = join(dir, 'project');
+  mkdirSync(project);
+  const server = await startModelServer(() => ({ text: 'Verification follow-up received.' }));
+  writeModelConfig(agentDir, server.port);
+  const cli = resolve(root, 'node_modules/@earendil-works/pi-coding-agent/dist/bundle/cli.js');
+  const child = spawn(process.execPath, [cli, '--mode', 'rpc', '--no-session', '--extension', resolve(root, 'src/extension.ts'), '--provider', 'loopback', '--model', 'loopback-model'], {
+    cwd: project,
+    env: { ...process.env, PI_CODING_AGENT_DIR: agentDir, PSTACK_NATIVE_HOME: home, PI_OFFLINE: '1' },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  const closed = new Promise<void>(resolveClose => child.once('close', () => resolveClose()));
+  child.stdout.setEncoding('utf8');
+  child.stderr.setEncoding('utf8');
+  let stderr = '', buffer = '', saved = false, settled = false;
+  const titles: string[] = [];
+  child.stderr.on('data', chunk => { stderr += String(chunk); });
+  const send = (record: unknown) => child.stdin.write(`${JSON.stringify(record)}\n`);
+  try {
+    await new Promise<void>((resolveDone, reject) => {
+      const timer = setTimeout(() => reject(new Error(`Pi RPC setup timed out (saved: ${saved}, calls: ${server.calls.length}): ${stderr}`)), 30_000);
+      child.once('error', error => { clearTimeout(timer); reject(error); });
+      child.once('exit', code => { if (!settled) { clearTimeout(timer); reject(new Error(`Pi RPC exited ${code}: ${stderr}`)); } });
+      child.stdout.on('data', chunk => {
+        buffer += String(chunk);
+        for (;;) {
+          const end = buffer.indexOf('\n');
+          if (end < 0) break;
+          const line = buffer.slice(0, end).replace(/\r$/, ''); buffer = buffer.slice(end + 1);
+          let event: any;
+          try { event = JSON.parse(line); } catch { clearTimeout(timer); reject(new Error(`Invalid Pi RPC record: ${line.slice(0, 200)}`)); return; }
+          if (event.type === 'extension_ui_request' && event.method === 'select') {
+            titles.push(event.title);
+            const value = event.title.startsWith('Child reasoning') ? event.options.find((option: string) => option.startsWith('inherit-parent'))
+              : event.title.startsWith('Review pstack') ? 'Save settings' : undefined;
+            if (!value) { clearTimeout(timer); reject(new Error(`Unexpected setup dialog: ${event.title}`)); return; }
+            send({ type: 'extension_ui_response', id: event.id, value });
+          }
+          if (event.type === 'extension_ui_request' && event.method === 'notify' && event.message.startsWith('Saved pstack settings')) saved = true;
+          if (event.type === 'response' && event.success === false) { clearTimeout(timer); reject(new Error(`Pi RPC: ${event.error}`)); return; }
+          if (event.type === 'agent_settled' && saved && server.calls.length) { settled = true; clearTimeout(timer); resolveDone(); return; }
+        }
+      });
+      send({ id: 'setup', type: 'prompt', message: '/setup-pstack' });
+    });
+    assert(titles.some(title => title.startsWith('Review pstack settings')));
+    const config = JSON.parse(readFileSync(join(home, 'models.json'), 'utf8'));
+    assert.equal(config.thinkingLevel, 'inherit-parent');
+    assert.deepEqual(config.panels.arena, ['loopback/loopback-model', 'loopback/loopback-model']);
+    assert.equal(server.calls.length, 1);
+    assert(server.calls[0]!.messages.some(message => JSON.stringify(message.content).includes('Complete the optional verification part')));
+  } finally {
+    child.kill();
+    await closed;
+    await server.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/test/smoke-installed-package.mjs

@@ -0,0 +1,119 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { execFileSync, spawnSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// Run this script with cwd set to a clean consumer directory after installing the
+// final .tgz. Resolve both the package and the peer SDK from that consumer.
+const installedManifestPath = fileURLToPath(new URL("../package.json", import.meta.url));
+const installedDir = dirname(installedManifestPath);
+const installedManifest = JSON.parse(readFileSync(installedManifestPath, "utf8"));
+const consumerRequire = createRequire(resolve(process.cwd(), "package.json"));
+assert.equal(realpathSync(consumerRequire.resolve(`${installedManifest.name}/package.json`)), realpathSync(installedManifestPath), "the installed package resolves by name from the consumer");
+const extensionPath = resolve(installedDir, installedManifest.pi.extensions[0]);
+// This SDK exposes its root entry only for ESM imports, not CommonJS require().
+const sdkRoot = resolve(process.cwd(), "node_modules/@earendil-works/pi-coding-agent");
+const sdkManifest = JSON.parse(readFileSync(join(sdkRoot, "package.json"), "utf8"));
+const sdkVersion = sdkManifest.version.split('.').map(Number);
+assert.ok(sdkVersion.length === 3 && sdkVersion.every(Number.isInteger) && sdkVersion[0] === 1 && sdkVersion[1] >= 4, "the installed peer satisfies the Pi 1.4+ / 1.x requirement");
+const sdkEntry = resolve(sdkRoot, sdkManifest.exports["."].import);
+const { createAgentSession, DefaultResourceLoader, SessionManager, loadSkillsFromDir } = await import(pathToFileURL(sdkEntry).href);
+
+const distEntry = resolve(installedDir, installedManifest.exports["."].import);
+const cliEntry = resolve(installedDir, installedManifest.bin["pstack-runner"]);
+for (const published of [distEntry, cliEntry]) assert.ok(readFileSync(published, "utf8").length > 0, `published runtime file is present: ${published}`);
+
+const api = await import(pathToFileURL(distEntry).href);
+for (const name of ["fingerprint", "sameFingerprint", "verify", "buildTemplate", "ProgramCoordinator", "contextSnapshot", "migrate", "runnerOnce"]) {
+  assert.equal(typeof api[name], "function", `published API exports ${name}`);
+}
+
+const sourceRead = await api.createResourceTools(join(installedDir, "skills"))[0].execute("installed-source", { action: "read", resource: "upstream/skills/poteto-mode/playbooks/shipping.md" });
+assert.equal(sourceRead.details.resource, "upstream/skills/poteto-mode/playbooks/shipping.md");
+assert.ok(sourceRead.details.lines.some(line => line.text.includes("### Shipping")), "installed upstream snapshot is readable with its verified blob ID");
+const installedSkills = loadSkillsFromDir({ dir: join(installedDir, "skills"), source: "path" });
+assert.deepEqual(installedSkills.diagnostics, [], "installed skills load without diagnostics");
+assert.equal(installedSkills.skills.filter(skill => skill.name === "ml-development").length, 1, "installed ML skill can be discovered by Pi");
+assert.match(readFileSync(join(installedDir, "skills/ml-development/SKILL.md"), "utf8"), /^disable-model-invocation: true$/m, "ML skill is explicitly invoked");
+const mlRead = await api.createResourceTools(join(installedDir, "skills"))[0].execute("installed-ml", { action: "read", resource: "ml-development/playbooks/02-data.md" });
+assert.ok(mlRead.details.lines.some(line => line.text.includes("leakage")), "installed ML playbook is accessible to children");
+const statechartHelp = spawnSync(process.execPath, [join(installedDir, "skills/statechart/scripts/statechart.mjs"), "--help"], { encoding: "utf8" });
+assert.equal(statechartHelp.status, 0, statechartHelp.stderr);
+assert.match(statechartHelp.stdout, /from-spec/);
+const statechartLatest = spawnSync(process.execPath, [join(installedDir, "dist/statechart/statechart.js")], { encoding: "utf8" });
+assert.equal(statechartLatest.status, 2, statechartLatest.stderr);
+assert.match(statechartLatest.stderr, /Usage: statechart SPEC\.tla/);
+
+const testRoot = mkdtempSync(join(process.cwd(), ".installed-package-smoke-"));
+const agentDir = join(testRoot, "pi-agent");
+const cwd = join(testRoot, "checkout");
+const pstackHome = join(testRoot, "pstack-native");
+mkdirSync(agentDir, { recursive: true });
+mkdirSync(cwd, { recursive: true });
+mkdirSync(pstackHome, { recursive: true });
+if (process.env.TLA2TOOLS) {
+  const spec = join(installedDir, 'skills/statechart/scripts/test/corpus/Counter/Counter.tla');
+  const out = join(testRoot, 'statechart-output');
+  const checked = spawnSync(process.execPath, [join(installedDir, 'dist/statechart/statechart.js'), spec, '--out', out], { encoding: 'utf8', timeout: 120000 });
+  assert.equal(checked.status, 0, checked.stderr);
+  assert.ok(existsSync(join(out, 'report.md')) && existsSync(join(out, 'chart.mmd')));
+}
+process.env.PI_CODING_AGENT_DIR = agentDir;
+process.env.PSTACK_NATIVE_HOME = pstackHome;
+writeFileSync(join(cwd, "sample.txt"), "baseline\n");
+for (const args of [["init", "-q"], ["config", "user.name", "Smoke"], ["config", "user.email", "smoke@example.invalid"], ["add", "."], ["commit", "-qm", "baseline"]]) {
+  execFileSync("git", ["-C", cwd, ...args], { stdio: "ignore" });
+}
+const before = api.fingerprint(cwd);
+assert.equal(before.kind, "working");
+assert.equal(before.dirty, false);
+assert.deepEqual(Object.keys(before.files), ["sample.txt"]);
+assert.equal(api.sameFingerprint(before, api.fingerprint(cwd)), true);
+writeFileSync(join(cwd, "sample.txt"), "changed\n");
+assert.equal(api.sameFingerprint(before, api.fingerprint(cwd)), false);
+writeFileSync(join(cwd, "sample.txt"), "baseline\n");
+
+const noArgs = spawnSync(process.execPath, [cliEntry], { encoding: "utf8" });
+assert.equal(noArgs.status, 1, "the published CLI rejects an unknown action");
+assert.match(noArgs.stderr, /Usage: pstack-runner run CONFIG/, "the published CLI prints its usage");
+const migrate = spawnSync(process.execPath, [cliEntry, "migrate"], { encoding: "utf8" });
+assert.equal(migrate.status, 0, "the published CLI migrates an empty store without failing");
+assert.deepEqual(JSON.parse(migrate.stdout), { dryRun: true, records: [] }, "empty store migration invents no records");
+
+let session;
+try {
+  const resourceLoader = new DefaultResourceLoader({
+    cwd,
+    agentDir,
+    noExtensions: true,
+    additionalExtensionPaths: [extensionPath],
+    noSkills: true,
+    noPromptTemplates: true,
+    noThemes: true,
+  });
+  await resourceLoader.reload();
+  const loaded = await createAgentSession({
+    cwd,
+    agentDir,
+    sessionManager: SessionManager.inMemory(),
+    resourceLoader,
+    noTools: "builtin",
+  });
+  session = loaded.session;
+  assert.equal(loaded.extensionsResult.errors.length, 0, "installed extension loads without Pi diagnostics");
+  assert.ok(loaded.extensionsResult.extensions.some((extension) => extension.path === extensionPath));
+  for (const name of ["pstack_semantics", "pstack_skill", "pstack_agents", "pstack_workflow", "pstack_graph", "pstack_worktrees", "pstack_verify", "pstack_delivery", "pstack_context", "pstack_program"]) {
+    assert.ok(session.getAllTools().some((tool) => tool.name === name), `installed package registered ${name}`);
+    assert.ok(session.getActiveToolNames().includes(name), `installed package activated ${name}`);
+  }
+  console.log(`installed package smoke PASS: ${installedManifestPath}`);
+  console.log(`real Pi SDK entry PASS: ${sdkEntry}`);
+  console.log(`published API PASS: ${distEntry}`);
+  console.log(`published CLI PASS: ${cliEntry}`);
+  console.log(`registered tools PASS: ${session.getActiveToolNames().filter((name) => name.startsWith("pstack_")).join(", ")}`);
+} finally {
+  session?.dispose();
+  rmSync(testRoot, { recursive: true, force: true });
+}

package/test/statechart.test.ts

@@ -0,0 +1,25 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {spawnSync} from 'node:child_process';
+// @ts-ignore bundled upstream implementation
+import {parseMermaid} from '../skills/statechart/scripts/lib.mjs';
+import { parseDot } from '../skills/statechart/scripts/frontends/dot.ts';
+test('statechart: bundled CLI is discoverable and preserves composite transitions',()=>{
+ const result=spawnSync(process.execPath,['skills/statechart/scripts/statechart.mjs','--help'],{encoding:'utf8'});
+ assert.equal(result.status,0,result.stderr);assert.match(result.stdout,/from-spec/);assert.match(result.stdout,/from-chart/);
+ const model=parseMermaid('stateDiagram-v2\nstate Running {\n [*] --> Waiting\n Waiting --> Done: finish\n}\n[*] --> Running\nRunning --> Stopped: cancel\n');
+ const transitions=model.regions.Main.transitions;
+ assert.ok(transitions.some((t:any)=>t.from==='Running.Waiting' && t.to==='Stopped' && t.label==='cancel'));
+ assert.ok(transitions.some((t:any)=>t.from==='Running.Done' && t.to==='Stopped' && t.label==='cancel'));
+});
+
+test('statechart 0.15.36: TypeScript CLI and DOT parser are available',()=>{
+ const result=spawnSync(process.execPath,['--disable-warning=ExperimentalWarning','skills/statechart/scripts/statechart.ts'],{encoding:'utf8'});
+ assert.equal(result.status,2,result.stderr);assert.match(result.stderr,/Usage: statechart SPEC\.tla/);
+ const graph=parseDot('digraph states {\n  1 [label="/\\ phase = \\"ready\\""];\n}\n');
+ assert.ok(graph);
+ const installed=spawnSync(process.execPath,['dist/statechart/statechart.js'],{encoding:'utf8'});
+ assert.equal(installed.status,2,installed.stderr);assert.match(installed.stderr,/Usage: statechart SPEC\.tla/);
+ const build=spawnSync(process.execPath,['scripts/build-statechart.mjs','--check'],{encoding:'utf8'});
+ assert.equal(build.status,0,build.stderr);
+});

package/test/store.test.ts

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { appendJournal, readJson, writeJsonAtomic } from "../src/runtime/store.ts";
+
+test("atomic JSON records and journals round-trip", () => {
+  const dir = mkdtempSync(join(process.cwd(), ".pstack-store-"));
+  try {
+    const file = join(dir, "state", "x.json");
+    writeJsonAtomic(file, { a: 1 });
+    assert.deepEqual(readJson(file, {}), { a: 1 });
+    writeJsonAtomic(file, { a: 2 });
+    assert.deepEqual(readJson(file, {}), { a: 2 });
+    assert.deepEqual(readdirSync(join(dir, "state")), ["x.json"]);
+    const journal = join(dir, "journal", "x.jsonl");
+    appendJournal(journal, { type: "created", n: 1 });
+    appendJournal(journal, { type: "done", n: 2 });
+    const lines = readFileSync(journal, "utf8").trim().split("\n").map((line) => JSON.parse(line));
+    assert.equal(lines.length, 2);
+    assert.equal(lines[0].type, "created");
+    assert.equal(lines[1].type, "done");
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});
+
+test("failed atomic replacement cleans its temporary file and preserves the destination", () => {
+  const dir = mkdtempSync(join(process.cwd(), ".pstack-store-"));
+  try {
+    const target = join(dir, "destination");
+    mkdirSync(target);
+    assert.throws(() => writeJsonAtomic(target, { saved: true }));
+    assert.deepEqual(readdirSync(dir), ["destination"]);
+    assert.deepEqual(readdirSync(target), []);
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});

package/test/swarm-race.test.ts

@@ -0,0 +1,50 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { capture, fingerprint, ownerOf } from '../src/artifacts/fingerprint.ts';
+import { reportSatisfies } from '../src/contracts/brief.ts';
+import { buildTemplate } from '../src/templates/build.ts';
+import { WorkflowEngine } from '../src/workflow/engine.ts';
+import { saveModels } from '../src/runtime/config.ts';
+
+test('swarm first-pass waits for an accepted candidate and stops remaining sessions', async () => {
+ const root=mkdtempSync(join(tmpdir(),'swarm-first-')), old=process.env.PSTACK_NATIVE_HOME;process.env.PSTACK_NATIVE_HOME=join(root,'home');
+ const cwd=join(root,'repo');mkdirSync(cwd);const git=(...args:string[])=>execFileSync('git',['-C',cwd,...args],{encoding:'utf8'}).trim();
+ git('init','-q');git('config','user.name','test');git('config','user.email','test@example.invalid');writeFileSync(join(cwd,'base.txt'),'base\n');git('add','.');git('commit','-qm','base');
+ const model={provider:'p',id:'model',reasoning:true};const ctx:any={cwd,model,thinkingLevel:'off',scopedModels:[],modelRegistry:{find:()=>model,getAvailable:()=>[model]},sessionManager:{getSessionId:()=> 'parent'}};
+ const brief:any={id:'first',revision:1,contractLevel:'strict',goal:'run candidate',scope:{repoId:fingerprint(cwd).repoId,include:['**'],exclude:[]},contextRefs:[],acceptance:[{id:'ok',description:'base exists',required:true,gateIds:['file']}],verification:[{id:'file',kind:'file',path:'base.txt',pattern:'base'}],forbidden:[],standingOrders:[],reportFormat:'task-report-v1',timeboxSeconds:30};
+ const records=new Map<string,any>();let release:((value:any)=>void)|undefined;let stopped='';
+ const host:any={get:(id:string)=>records.get(id),async run(spec:any){
+   if(spec.callKey==='candidate-2'){const running={...spec,state:'running'};records.set(spec.id,running);return await new Promise(resolve=>{release=resolve;});}
+   const base=capture(spec.cwd,undefined,[],'working',{kind:'baseline',owner:ownerOf(spec.brief,{workflowId:spec.workflowId,callKey:spec.callKey})}).fingerprint;
+   const report={status:'completed',base:base.commitSha,head:base.commitSha,artifactRefs:[],commandsRun:[],evidenceRefs:[],deviations:[],unresolved:[],nextActions:[]};
+   const done={...spec,state:'completed',baseline:base,report,result:'passed'};records.set(spec.id,done);return done;
+ },async stop(id:string){stopped=id;const result={...records.get(id),state:'cancelled'};records.set(id,result);release?.(result);return result;}};
+ try{
+   saveModels({version:1,roles:{worker:'p/model'},thinkingLevel:'inherit-parent'});
+   const plan=buildTemplate({kind:'swarm',swarmMode:'race',selectionPolicy:'first-pass',candidateCount:2,brief},ctx);
+   const engine=new WorkflowEngine(host), created=engine.create({type:'swarm',completionPolicy:plan.completionPolicy,cwd,nodes:plan.nodes,parentSessionId:'parent'});
+   const done=await engine.run(created.id,ctx);
+   assert.equal(done.state,'completed');assert.equal(done.firstPassWinner,'candidate-1');assert.equal(done.verification,'verified');
+   assert.equal(done.calls['candidate-2'].state,'cancelled');assert.equal(done.calls['candidate-2'].excludedFromSelection,true);assert.equal(stopped,done.calls['candidate-2'].agentId);
+   assert.equal(done.calls['candidate-1'].verification?.status,'passed');
+ }finally{if(old===undefined)delete process.env.PSTACK_NATIVE_HOME;else process.env.PSTACK_NATIVE_HOME=old;rmSync(root,{recursive:true,force:true});}
+});
+
+test('rank-all requires each candidate exactly once with a unique rank',()=>{
+ const brief:any={reportRequirements:{kind:'ranking',candidates:['candidate-1','candidate-2']}};
+ const ranking=[{candidate:'candidate-1',rank:1,reason:'simpler'},{candidate:'candidate-2',rank:2,reason:'more complex'}];
+ assert(reportSatisfies(brief,{ranking} as any));
+ assert.equal(reportSatisfies(brief,{ranking:ranking.slice(0,1)} as any),false);
+ assert.equal(reportSatisfies(brief,{ranking:[ranking[0],{...ranking[1],rank:1}]} as any),false);
+});
+
+test('rank-all plans a complete comparison without integrating a winner',()=>{
+ const brief:any={id:'rank',revision:1,contractLevel:'strict',goal:'compare candidates',scope:{repoId:'fixture',include:['**'],exclude:[]},contextRefs:[],acceptance:[{id:'ok',description:'ok',required:true,gateIds:['file']}],verification:[{id:'file',kind:'file',path:'base.txt'}],forbidden:[],standingOrders:[],reportFormat:'task-report-v1',timeboxSeconds:30};
+ const plan=buildTemplate({kind:'swarm',swarmMode:'race',selectionPolicy:'rank-all',brief,models:['p/a','p/b'],judgeModel:'p/j',rubric:[{criterion:'correctness',weight:1}]});
+ assert.equal(plan.nodes.find(n=>n.key==='rank')?.brief?.reportRequirements?.kind,'ranking');
+ assert.equal(plan.nodes.some(n=>n.profile==='integrator'),false);
+});

package/test/tool-ownership.test.ts

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerAgentTool } from "../src/tools/agents.ts";
+import { registerWorkflowTool } from "../src/tools/workflow.ts";
+import { registerWorktreeTool } from "../src/tools/worktrees.ts";
+
+function capture(register: (pi: any, runtime: any) => void, runtime: any): any {
+  let tool: any;
+  register({ registerTool(t: any) { tool = t; } }, runtime);
+  return tool;
+}
+const ctx = { cwd: "/repo", sessionManager: { getSessionId() { return "my-session"; } } } as any;
+const otherAgent = { id: "ag_other", state: "running", parentSessionId: "other-session", worktree: "/repo/other" };
+const ownAgent = { id: "ag_own", state: "completed", parentSessionId: "my-session", worktree: "/repo/own" };
+const otherWorkflow = { id: "wf_other", parentSessionId: "other-session" };
+const ownWorkflow = { id: "wf_own", parentSessionId: "my-session" };
+
+test("agent tools do not leak status or let one session control another session's agent", async () => {
+  let touched = false;
+  const runtime = {
+    list: () => [otherAgent, ownAgent],
+    get: (id: string) => id === otherAgent.id ? otherAgent : id === ownAgent.id ? ownAgent : undefined,
+    send: async () => { touched = true; }, stop: async () => { touched = true; },
+  };
+  const tool = capture(registerAgentTool, runtime);
+  const execute = (action: string, id?: string) => tool.execute("1", { action, id, message: "hello" }, undefined, undefined, ctx);
+  assert.deepEqual((await execute("list")).details.map((r: any) => r.id), ["ag_own"]);
+  for (const action of ["status", "send", "stop"]) await assert.rejects(() => execute(action, "ag_other"), /not found in this Pi session/);
+  assert.equal(touched, false);
+  assert.equal((await execute("status", "ag_own")).details.id, "ag_own");
+});
+
+test("workflow tools scope every lifecycle operation to the calling session", async () => {
+  let mutated = false;
+  const runtime = {
+    get: (id: string) => id === "wf_other" ? otherWorkflow : ownWorkflow,
+    list: () => [ownWorkflow],
+    pause: () => { mutated = true; }, resume: () => { mutated = true; },
+    cancel: async () => { mutated = true; }, retry: () => { mutated = true; },
+  };
+  const tool = capture(registerWorkflowTool, runtime);
+  for (const action of ["status", "pause", "resume", "cancel", "retry"]) {
+    await assert.rejects(() => tool.execute("1", { action, id: "wf_other", key: "a" }, undefined, undefined, ctx), /not found in this Pi session/);
+  }
+  assert.equal(mutated, false);
+});
+
+test("worktree cleanup cannot operate on another session's agent", async () => {
+  let removed = false;
+  const runtime = {
+    get: (id: string) => id === "ag_other" ? otherAgent : ownAgent,
+    list: () => [otherAgent, ownAgent],
+    cleanupWorktree: async () => { removed = true; },
+  };
+  const tool = capture(registerWorktreeTool, runtime);
+  assert.deepEqual((await tool.execute("1", { action: "list" }, undefined, undefined, ctx)).details.map((a: any) => a.agentId), ["ag_own"]);
+  await assert.rejects(() => tool.execute("1", { action: "cleanup", id: "ag_other" }, undefined, undefined, ctx), /not found in this Pi session/);
+  assert.equal(removed, false);
+});