pi-pstack-native 0.0.0-stage → 1.0.0

package/test/isolation.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { assertCompatibleIsolation } from "../src/agent/isolation.ts";
+import { getProfile } from "../src/agent/profiles.ts";
+
+test("writable profiles cannot bypass locks via readonly isolation", () => {
+  for (const name of ["worker", "architect", "poteto-agent", "integrator"]) {
+    assert.throws(() => assertCompatibleIsolation(getProfile(name), "readonly"), /cannot use readonly isolation/);
+  }
+  assert.doesNotThrow(() => assertCompatibleIsolation(getProfile("worker"), "shared"));
+  assert.doesNotThrow(() => assertCompatibleIsolation(getProfile("worker"), "worktree"));
+});
+
+test("integrators only write to the parent checkout; all read-only profiles exclude mutation-capable tools", () => {
+  assert.throws(() => assertCompatibleIsolation(getProfile("integrator"), "worktree"), /must use shared isolation/);
+  for (const name of ["reviewer", "verifier", "scout", "synthesizer", "comment-sicko"]) {
+    const profile = getProfile(name);
+    assert.equal(profile.writable, false);
+    assert.deepEqual(profile.tools.filter((tool) => ["bash", "write", "edit", "pstack_agents", "pstack_workflow"].includes(tool)), []);
+  }
+});

package/test/latest-upstream.test.ts

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFileSync} from 'node:fs';
+import {createHash} from 'node:crypto';
+import {loadSkillsFromDir} from '@earendil-works/pi-coding-agent';
+import {evaluateRound, type Round} from '../src/compatibility/adapter.ts';
+// @ts-ignore shared ESM tooling
+import {generatedResources, renderCore} from '../scripts/semantics/generate.mjs';
+const read=(path:string)=>JSON.parse(readFileSync(path,'utf8'));
+test('latest source: every supported 0.15.36 Skill and playbook retains its pinned body and loads on Pi 1.4',()=>{
+ const upstream=read('UPSTREAM.json'),manifest=read('SEMANTICS.json'),parity=read('PARITY.json');
+ assert.equal(upstream.version,'0.15.36');assert.equal(upstream.commit,'c742dd61706fbacc1b95f1a20b7b988cf096ce6c');
+ assert.equal(manifest.snapshot.commit,upstream.commit);
+ assert.equal(read('package-lock.json').packages['node_modules/@earendil-works/pi-coding-agent'].version,'1.4.0');
+ assert.equal(Object.keys(parity.skills).length,58);assert.equal(parity.skills['make-bot-ui'],'CURSOR_ONLY');assert.equal(parity.skills.statechart,'ADAPTED');
+ const loaded=loadSkillsFromDir({dir:process.cwd()+'/skills',source:'path'});assert.deepEqual(loaded.diagnostics,[]);assert.ok(loaded.skills.some(s=>s.name==='statechart'));
+ const resources=generatedResources(process.cwd());assert.equal(resources.length,80);
+ for(const resource of resources){const body=readFileSync(`${manifest.snapshot.root}/pstack/skills/${resource}`,'utf8').replace(/^---\n[\s\S]*?\n---\n/,'');assert.ok(renderCore(process.cwd(),resource).includes(body),resource);}
+ const target=read(parity.coverage.targetInventory);
+ for(const entry of target.blobs.filter((v:any)=>v.path.startsWith('skills/statechart/scripts/'))) {
+   const bytes=readFileSync(entry.path);const hash=createHash('sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex');
+   assert.equal(hash,entry.blob,entry.path);
+ }
+});
+function full():Round {
+ const head='a'.repeat(40),base='b'.repeat(40),lanes=['gates','live','diff-1','diff-2','trunk-regression'];
+ return {workflow:'autopilot-full',head,base,writer:'author',requiredLanes:lanes,receipts:lanes.map(lane=>({lane,actor:`reviewer-${lane}`,head,base,status:'passed',evidence:[`${lane}.log`]})),checksPassed:true,unresolvedFindings:0,authorization:false,requestedAction:'verdict'};
+}
+function followup():Round {
+ const head='c'.repeat(40),base='b'.repeat(40),lanes=['gates','live','follow-up-review'];
+ return {...full(),head,base,changeKind:'minor',priorRound:full(),requiredLanes:lanes,receipts:lanes.map(lane=>({lane,actor:'independent-followup',head,base,status:'passed',evidence:[`new-${lane}.log`]}))};
+}
+test('latest autopilot: minor rebase and conflict follow-ups need a prior full swarm and fresh independent receipts',()=>{
+ for(const changeKind of ['minor','rebase','conflict'] as const)assert.equal(evaluateRound({...followup(),changeKind}).clean,true);
+ for(const changeKind of ['initial','major'] as const)assert.equal(evaluateRound({...followup(),changeKind}).clean,false);
+ const missing=followup();delete missing.priorRound;assert.ok(evaluateRound(missing).blockers.includes('PRIOR_FULL_SWARM_REQUIRED'));
+ const failed=followup();failed.priorRound!.checksPassed=false;assert.equal(evaluateRound(failed).clean,false);
+ const stale=followup();stale.receipts[0].head=stale.priorRound!.head;assert.equal(evaluateRound(stale).clean,false);
+ const self=followup();self.writer='replacement';self.receipts[0].actor=self.priorRound!.writer;assert.equal(evaluateRound(self).clean,false);
+ const quiet=followup();quiet.receipts=quiet.receipts.filter(r=>r.lane!=='live');assert.equal(evaluateRound(quiet).clean,false);
+});

package/test/live/command-probe-child.mjs

@@ -0,0 +1,22 @@
+import { appendFileSync } from "node:fs";
+import real from "node:child_process";
+
+const flatten = (value) => Array.isArray(value) ? value.flatMap(flatten) : typeof value === "string" ? [value] : [];
+
+function record(name, args) {
+  const file = process.env.PSTACK_E2E_COMMAND_PROBE;
+  if (!file) return;
+  try { appendFileSync(file, `${JSON.stringify({ name, command: args.flatMap(flatten).join(" ") })}\n`); } catch {}
+}
+
+const wrap = (name) => (...args) => { record(name, args); return real[name](...args); };
+
+export const execFileSync = wrap("execFileSync");
+export const execFile = wrap("execFile");
+export const execSync = wrap("execSync");
+export const exec = wrap("exec");
+export const spawn = wrap("spawn");
+export const spawnSync = wrap("spawnSync");
+export const fork = wrap("fork");
+
+export default { ...real, execFileSync, execFile, execSync, exec, spawn, spawnSync, fork };

package/test/live/command-probe-loader.mjs

@@ -0,0 +1,8 @@
+const WRAPPER = new URL("./command-probe-child.mjs", import.meta.url).href;
+
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier === "node:child_process" && context.parentURL !== WRAPPER) {
+    return { url: WRAPPER, format: "module", shortCircuit: true };
+  }
+  return nextResolve(specifier, context);
+}

package/test/live/command-probe-register.mjs

@@ -0,0 +1,12 @@
+import { registerHooks } from "node:module";
+
+const WRAPPER = new URL("./command-probe-child.mjs", import.meta.url).href;
+
+registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if (specifier === "node:child_process" && context.parentURL !== WRAPPER) {
+      return { url: WRAPPER, format: "module", shortCircuit: true };
+    }
+    return nextResolve(specifier, context);
+  },
+});

package/test/live/github-live.test.ts

@@ -0,0 +1,107 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fingerprint } from "../../src/artifacts/fingerprint.ts";
+import { GitHubCLI } from "../../src/delivery/provider.ts";
+import { refresh, eligibility, ship } from "../../src/delivery/frontier.ts";
+import { LIVE } from "../e2e/harness.ts";
+import { liveTier } from "./guard.ts";
+
+const read = liveTier("read");
+const write = liveTier("write");
+const merge = liveTier("merge");
+
+test(`${LIVE} reads the operator-named repository and its pull request state through gh`, { skip: read.skip, timeout: 300_000 }, async () => {
+  if (!read.open) return;
+  const target = read;
+  const provider = new GitHubCLI();
+  assert.equal(target.open, true);
+  if (target.pr) {
+    const pr = await provider.read(target.repo, target.pr);
+    assert.equal(pr.repo, target.repo);
+    assert.match(pr.headSha, /^[0-9a-f]{40}$/);
+    assert.match(pr.baseSha, /^[0-9a-f]{40}$/);
+    const spec = { id: "live-read", repoId: fingerprint(target.clone ?? process.cwd()).repoId, repo: target.repo, numbers: [target.pr], owner: "live-operator" };
+    const frontier = await refresh(spec, provider);
+    assert.equal(frontier.prs[0]!.repo, target.repo);
+    const plan = await ship(spec, provider) as { dryRun?: boolean };
+    assert.equal(plan.dryRun, true);
+    assert.equal(Array.isArray(eligibility(frontier)), true);
+    return;
+  }
+  const head = await provider.branchHead(target.repo, target.base);
+  assert.match(head, /^[0-9a-f]{40}$/);
+});
+
+test(`${LIVE} verifies a live pull request from an operator clone and closes it again`, { skip: write.skip, timeout: 600_000 }, async () => {
+  if (!write.open) return;
+  const target = write;
+  const provider = new GitHubCLI();
+  const clone = target.clone;
+  const branch = `pstack-e2e-${Date.now()}`;
+  const bodyFile = join(mkdtempSync(join(tmpdir(), "pstack-e2e-live-")), "body.md");
+  writeFileSync(bodyFile, `Live release gate probe for ${target.repo}.\n`);
+  let number: number | undefined;
+  const run = (args: string[]) => execFileSync("git", ["-C", clone, ...args], { encoding: "utf8" }).trim();
+  try {
+    run(["checkout", "-q", target.base]);
+    run(["checkout", "-q", "-b", branch]);
+    writeFileSync(join(clone, "PSTACK-E2E-LIVE.md"), `probe ${branch}\n`);
+    run(["add", "PSTACK-E2E-LIVE.md"]);
+    run(["commit", "-qm", "pstack e2e live probe"]);
+    const headSha = run(["rev-parse", "HEAD"]);
+    run(["push", "-q", "origin", `HEAD:refs/heads/${branch}`]);
+    const url = await provider.open(target.repo, target.base, branch, `pstack e2e live probe ${branch}`, bodyFile);
+    number = Number(url.match(/\/pull\/(\d+)$/)?.[1]);
+    assert.ok(Number.isSafeInteger(number), `expected a pull request number from ${url}`);
+    const pr = await provider.read(target.repo, number!);
+    assert.equal(pr.headSha, headSha);
+    assert.equal(pr.baseRef, target.base);
+    assert.equal(["passed", "failed", "pending", "unknown"].includes(pr.ci), true);
+    assert.equal(["approved", "changes-requested", "pending"].includes(pr.review), true);
+  } finally {
+    if (number) execFileSync("gh", ["pr", "close", String(number), "--repo", target.repo, "--delete-branch"], { encoding: "utf8" });
+    try { run(["push", "-q", "origin", "--delete", branch]); } catch { /* the branch is removed with the pull request */ }
+    run(["checkout", "-q", target.base]);
+    rmSync(join(clone, "PSTACK-E2E-LIVE.md"), { force: true });
+  }
+});
+
+test(`${LIVE} merges a live pull request from an operator clone`, { skip: merge.skip, timeout: 600_000 }, async () => {
+  if (!merge.open) return;
+  const target = merge;
+  const provider = new GitHubCLI();
+  const clone = target.clone;
+  const branch = `pstack-e2e-merge-${Date.now()}`;
+  const bodyFile = join(mkdtempSync(join(tmpdir(), "pstack-e2e-live-")), "body.md");
+  writeFileSync(bodyFile, `Live merge gate probe for ${target.repo}.\n`);
+  let number: number | undefined;
+  const run = (args: string[]) => execFileSync("git", ["-C", clone, ...args], { encoding: "utf8" }).trim();
+  try {
+    run(["checkout", "-q", target.base]);
+    run(["checkout", "-q", "-b", branch]);
+    writeFileSync(join(clone, "PSTACK-E2E-MERGE.md"), `probe ${branch}\n`);
+    run(["add", "PSTACK-E2E-MERGE.md"]);
+    run(["commit", "-qm", "pstack e2e live merge probe"]);
+    const headSha = run(["rev-parse", "HEAD"]);
+    run(["push", "-q", "origin", `HEAD:refs/heads/${branch}`]);
+    const url = await provider.open(target.repo, target.base, branch, `pstack e2e live merge probe ${branch}`, bodyFile);
+    number = Number(url.match(/\/pull\/(\d+)$/)?.[1]);
+    assert.ok(Number.isSafeInteger(number), `expected a pull request number from ${url}`);
+    const pr = await provider.read(target.repo, number!);
+    assert.equal(pr.headSha, headSha);
+    await provider.merge(pr);
+    const merged = await provider.read(target.repo, number!);
+    assert.equal(merged.state, "MERGED");
+    run(["fetch", "-q", "origin"]);
+    assert.doesNotThrow(() => execFileSync("git", ["-C", clone, "merge-base", "--is-ancestor", headSha, `origin/${target.base}`], { stdio: "ignore" }), "the merged commit must be reachable from the base branch");
+  } finally {
+    if (number) { try { execFileSync("gh", ["pr", "close", String(number), "--repo", target.repo, "--delete-branch"], { encoding: "utf8", stdio: "ignore" }); } catch { /* a merged pull request cannot be closed again */ } }
+    try { run(["push", "-q", "origin", "--delete", branch]); } catch { /* the branch is already removed */ }
+    try { run(["checkout", "-q", target.base]); } catch { /* the clone may be behind the merge */ }
+    rmSync(join(clone, "PSTACK-E2E-MERGE.md"), { force: true });
+  }
+});

package/test/live/guard.ts

@@ -0,0 +1,70 @@
+import { execFileSync } from "node:child_process";
+
+export type LiveRequirement = "read" | "write" | "merge";
+
+export interface LiveClosed { open: false; reason: string; skip: string }
+export interface LiveOpen { open: true; reason: string; repo: string; base: string; pr?: number; clone?: string; skip: false }
+export interface LiveWriteOpen extends LiveOpen { write: true; clone: string }
+export type LiveGate = LiveClosed | LiveOpen | LiveWriteOpen;
+
+type LiveTarget =
+  | { enabled: true; reason: string; repo: string; base: string; pr?: number; clone?: string; write: boolean; merge: boolean }
+  | { enabled: false; reason: string };
+
+const PROTECTED = new Set(["2333sky/pi-pstack-native"]);
+
+function checkoutRepo(cwd = process.cwd()): string | undefined {
+  try {
+    const remote = execFileSync("git", ["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    return remote.match(/(?:github\.com[/:])([\w.-]+\/[\w.-]+?)(?:\.git)?\/?$/)?.[1];
+  } catch { return undefined; }
+}
+
+let probedCheckout: { repo: string | undefined } | undefined;
+
+function currentCheckoutRepo(): string | undefined {
+  probedCheckout ??= { repo: checkoutRepo() };
+  return probedCheckout.repo;
+}
+
+/**
+ * The live tier is closed unless the operator names one repository, repeats its name,
+ * and supplies a clone for any write. Nothing derives a target from the environment.
+ */
+function liveTarget(env: NodeJS.ProcessEnv, checkout: string | undefined): LiveTarget {
+  const repo = env.PSTACK_E2E_LIVE_REPO ?? "";
+  const base = env.PSTACK_E2E_LIVE_BASE ?? "main";
+  const clone = env.PSTACK_E2E_LIVE_CLONE;
+  const write = env.PSTACK_E2E_LIVE_WRITE === "1";
+  const merge = env.PSTACK_E2E_LIVE_MERGE === "1";
+  const pr = Number.isSafeInteger(Number(env.PSTACK_E2E_LIVE_PR)) && Number(env.PSTACK_E2E_LIVE_PR) > 0 ? Number(env.PSTACK_E2E_LIVE_PR) : undefined;
+  const closed = (reason: string): LiveTarget => ({ enabled: false, reason });
+  if (env.PSTACK_E2E_LIVE !== "1") return closed("PSTACK_E2E_LIVE is not set to 1");
+  if (!/^[\w.-]+\/[\w.-]+$/.test(repo)) return closed("PSTACK_E2E_LIVE_REPO must name one owner/repository explicitly");
+  if (env.PSTACK_E2E_LIVE_CONFIRM !== repo) return closed("PSTACK_E2E_LIVE_CONFIRM must repeat the exact repository name");
+  if (PROTECTED.has(repo.toLowerCase())) return closed(`${repo} is a protected repository`);
+  if (write && !clone) return closed("PSTACK_E2E_LIVE_WRITE requires an explicit PSTACK_E2E_LIVE_CLONE");
+  const current = checkout ?? currentCheckoutRepo();
+  if (current && current.toLowerCase() === repo.toLowerCase()) return closed("refusing the repository of the current checkout");
+  return { enabled: true, reason: "explicitly named by the operator", repo, base, pr, clone, write, merge };
+}
+
+export function liveTier(requirement?: "read", env?: NodeJS.ProcessEnv, checkout?: string): LiveClosed | LiveOpen;
+export function liveTier(requirement: "write", env?: NodeJS.ProcessEnv, checkout?: string): LiveClosed | LiveWriteOpen;
+export function liveTier(requirement: "merge", env?: NodeJS.ProcessEnv, checkout?: string): LiveClosed | LiveWriteOpen;
+export function liveTier(requirement: LiveRequirement = "read", env: NodeJS.ProcessEnv = process.env, checkout?: string): LiveGate {
+  const target = liveTarget(env, checkout);
+  if (!target.enabled) return { open: false, reason: target.reason, skip: `live tier closed: ${target.reason}` };
+  const open = {
+    open: true as const,
+    reason: target.reason,
+    repo: target.repo,
+    base: target.base,
+    ...(target.pr === undefined ? {} : { pr: target.pr }),
+    ...(target.clone === undefined ? {} : { clone: target.clone }),
+  };
+  if (requirement === "read") return { ...open, skip: false as const };
+  if (!target.write || !target.clone) return { open: false, reason: "PSTACK_E2E_LIVE_WRITE is not set to 1", skip: "requires PSTACK_E2E_LIVE_WRITE=1 with an explicit PSTACK_E2E_LIVE_CLONE" };
+  if (requirement === "merge" && !target.merge) return { open: false, reason: "PSTACK_E2E_LIVE_MERGE is not set to 1", skip: "requires PSTACK_E2E_LIVE_MERGE=1 in addition to PSTACK_E2E_LIVE_WRITE=1" };
+  return { ...open, write: true as const, clone: target.clone, skip: false as const };
+}

package/test/lock.test.ts

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { FileLock } from "../src/runtime/lock.ts";
+
+test("lock recovers immediately from a dead owner even when the file is fresh", () => {
+  const dir = mkdtempSync(join(process.cwd(), ".pstack-lock-"));
+  try {
+    const path = join(dir, "workflow.lock");
+    writeFileSync(path, JSON.stringify({ pid: 2_147_483_647, at: new Date().toISOString() }));
+    const lock = new FileLock(path, 60 * 60_000);
+    assert.equal(lock.acquire(), true);
+    lock.release();
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("lock does not steal a lock from a live owner", () => {
+  const dir = mkdtempSync(join(process.cwd(), ".pstack-lock-live-"));
+  try {
+    const path = join(dir, "workflow.lock");
+    writeFileSync(path, JSON.stringify({ pid: process.pid, at: new Date().toISOString() }));
+    const lock = new FileLock(path, 0);
+    assert.equal(lock.acquire(), false);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("failed lock contender release cannot unlink an active owner's lock", () => {
+  const dir = mkdtempSync(join(process.cwd(), ".pstack-lock-contender-"));
+  try {
+    const path = join(dir, "writer.lock");
+    const a = new FileLock(path);
+    const b = new FileLock(path);
+    assert.equal(a.acquire(), true);
+    assert.equal(b.acquire(), false);
+    b.release();
+    assert.equal(new FileLock(path).acquire(), false, "third writer must not enter");
+    a.release();
+    const c = new FileLock(path);
+    assert.equal(c.acquire(), true);
+    c.release();
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});
+
+test("an old owner's release cannot erase a replacement lock", () => {
+  const dir = mkdtempSync(join(process.cwd(), ".pstack-lock-replace-"));
+  try {
+    const path = join(dir, "writer.lock");
+    const old = new FileLock(path);
+    assert.equal(old.acquire(), true);
+    // Simulate external replacement of the pathname with a different inode.
+    rmSync(path);
+    writeFileSync(path, JSON.stringify({ pid: process.pid, owner: "another-owner" }));
+    old.release();
+    const contender = new FileLock(path);
+    assert.equal(contender.acquire(), false);
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});
+
+test("EPERM during a liveness probe does not prove the lock owner has died", () => {
+  const dir = mkdtempSync(join(process.cwd(), ".pstack-lock-eperm-"));
+  const kill = process.kill;
+  try {
+    const path = join(dir, "writer.lock");
+    writeFileSync(path, JSON.stringify({ pid: process.pid, owner: "external" }));
+    process.kill = ((pid: number, signal: any) => {
+      if (signal === 0) throw Object.assign(new Error("Access denied"), { code: "EPERM" });
+      return kill(pid, signal);
+    }) as typeof process.kill;
+    assert.equal(new FileLock(path).acquire(), false);
+  } finally { process.kill = kill; rmSync(dir, { recursive: true, force: true }); }
+});