pi-pstack-native 0.0.0-stage → 1.0.0

package/test/e2e/offline.test.ts

@@ -0,0 +1,153 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { GitHubCLI } from "../../src/delivery/provider.ts";
+import { liveTier } from "../live/guard.ts";
+import { OFFLINE, cleanEnv, git, githubClient, initFixtureRepo, redactCaptured, startGitHubServer } from "./harness.ts";
+
+const PROTECTED = "2333sky/pi-pstack-native";
+const REPO = "loopback-owner/lemn-disposable";
+
+test(`${OFFLINE} the credentialed live tier never runs without an explicit operator target`, () => {
+  const none = liveTier("read", {}, PROTECTED);
+  assert.equal(none.open, false);
+  assert.match(none.reason, /PSTACK_E2E_LIVE is not set/);
+  assert.equal(liveTier("read", { PSTACK_E2E_LIVE: "1" }, PROTECTED).open, false);
+  assert.equal(liveTier("read", { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: "owner/name" }, PROTECTED).open, false);
+  assert.equal(liveTier("read", { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: "owner/name", PSTACK_E2E_LIVE_CONFIRM: "owner/other" }, PROTECTED).open, false);
+  assert.equal(liveTier("read", { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: PROTECTED, PSTACK_E2E_LIVE_CONFIRM: PROTECTED }, PROTECTED).open, false);
+  assert.equal(liveTier("read", { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: "owner/name", PSTACK_E2E_LIVE_CONFIRM: "owner/name" }, "owner/name").open, false);
+  assert.match(liveTier("write", { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: "owner/name", PSTACK_E2E_LIVE_CONFIRM: "owner/name", PSTACK_E2E_LIVE_WRITE: "1" }, PROTECTED).reason, /PSTACK_E2E_LIVE_CLONE/);
+  const named = liveTier("read", { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: "owner/name", PSTACK_E2E_LIVE_CONFIRM: "owner/name" }, PROTECTED);
+  assert.equal(named.open, true);
+  assert.equal(named.repo, "owner/name");
+  const operator = { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: "owner/name", PSTACK_E2E_LIVE_CONFIRM: "owner/name" };
+  assert.equal(liveTier("write", operator, PROTECTED).open, false);
+  const residual = { PSTACK_E2E_LIVE_WRITE: "1", PSTACK_E2E_LIVE_CLONE: "/tmp/absent-clone" };
+  assert.equal(liveTier("read", residual, PROTECTED).open, false);
+  assert.equal(liveTier("write", residual, PROTECTED).open, false);
+  assert.equal(liveTier("merge", residual, PROTECTED).open, false);
+  const writable = { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: "owner/name", PSTACK_E2E_LIVE_CONFIRM: "owner/name", PSTACK_E2E_LIVE_WRITE: "1", PSTACK_E2E_LIVE_CLONE: "/tmp/absent-clone" };
+  assert.equal(liveTier("write", writable, PROTECTED).open, true);
+  assert.equal(liveTier("merge", writable, PROTECTED).open, false);
+  assert.match(liveTier("merge", writable, PROTECTED).reason, /PSTACK_E2E_LIVE_MERGE is not set/);
+  assert.equal(liveTier("merge", { ...writable, PSTACK_E2E_LIVE_MERGE: "1" }, PROTECTED).open, true);
+});
+
+test(`${OFFLINE} the live tier is skipped by default when its own file runs`, { timeout: 120_000 }, () => {
+  const file = join("test", "live", "github-live.test.ts");
+  const env = cleanEnv({ PSTACK_E2E_LIVE: "", PSTACK_E2E_LIVE_REPO: "", PSTACK_E2E_LIVE_CONFIRM: "", PSTACK_E2E_LIVE_WRITE: "", PSTACK_E2E_LIVE_MERGE: "" });
+  const run = spawnSync(process.execPath, ["--experimental-strip-types", "--test", "--test-reporter=tap", file], { cwd: process.cwd(), encoding: "utf8", env });
+  assert.equal(run.status, 0, run.stdout + run.stderr);
+  assert.match(run.stdout, /^# skipped 3$/m);
+  assert.match(run.stdout, /^# fail 0$/m);
+});
+
+const CHECKOUT_PROBE = "git -C <current checkout> remote get-url origin";
+
+function observedCommands(probe: string): string[] {
+  if (!existsSync(probe)) return [];
+  return readFileSync(probe, "utf8").split("\n").filter(Boolean).map((line) => String(JSON.parse(line).command))
+    .map((command) => /^git -C .+ remote get-url origin$/.test(command) ? CHECKOUT_PROBE : command);
+}
+
+function matrixEnv(row: Record<string, string>, preload: string, probe: string): NodeJS.ProcessEnv {
+  const env = cleanEnv();
+  for (const key of Object.keys(env)) if (key.startsWith("PSTACK_E2E_LIVE")) delete env[key];
+  for (const [key, value] of Object.entries(row)) env[key] = value;
+  env.NODE_OPTIONS = `--import=${preload}`;
+  env.PSTACK_E2E_COMMAND_PROBE = probe;
+  return env;
+}
+
+test(`${OFFLINE} every refused live-tier environment runs no external command and enters no write path`, { timeout: 300_000 }, async (t) => {
+  const root = mkdtempSync(join(process.cwd(), ".e2e-live-matrix-"));
+  const probe = join(root, "observed-commands.jsonl");
+  const preload = pathToFileURL(resolve("test", "live", "command-probe-register.mjs")).href;
+  const liveFile = resolve("test", "live", "github-live.test.ts");
+  const residual = { PSTACK_E2E_LIVE_WRITE: "1", PSTACK_E2E_LIVE_CLONE: join(root, "absent-clone") };
+  const named = { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: REPO, PSTACK_E2E_LIVE_CONFIRM: REPO };
+  const rows: Array<{ label: string; env: Record<string, string>; origin?: string; expected: string[] }> = [
+    { label: "no live environment at all", env: {}, expected: [] },
+    { label: "a residual PSTACK_E2E_LIVE_WRITE and PSTACK_E2E_LIVE_CLONE with nothing else", env: residual, expected: [] },
+    { label: "a residual write and clone plus a repository name", env: { ...residual, PSTACK_E2E_LIVE_REPO: REPO }, expected: [] },
+    { label: "a residual write and clone with the full operator name minus PSTACK_E2E_LIVE", env: { ...residual, PSTACK_E2E_LIVE_REPO: REPO, PSTACK_E2E_LIVE_CONFIRM: REPO }, expected: [] },
+    { label: "a residual PSTACK_E2E_LIVE_CLONE alone", env: { PSTACK_E2E_LIVE_CLONE: residual.PSTACK_E2E_LIVE_CLONE }, expected: [] },
+    { label: "PSTACK_E2E_LIVE=1 with no repository", env: { PSTACK_E2E_LIVE: "1" }, expected: [] },
+    { label: "PSTACK_E2E_LIVE=1 with a repository and no confirmation", env: { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: REPO }, expected: [] },
+    { label: "PSTACK_E2E_LIVE=1 with a mismatched confirmation", env: { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: REPO, PSTACK_E2E_LIVE_CONFIRM: "loopback-owner/other" }, expected: [] },
+    { label: "PSTACK_E2E_LIVE=1 naming the protected repository", env: { PSTACK_E2E_LIVE: "1", PSTACK_E2E_LIVE_REPO: PROTECTED, PSTACK_E2E_LIVE_CONFIRM: PROTECTED }, expected: [] },
+    { label: "PSTACK_E2E_LIVE=1 with write and no clone", env: { ...named, PSTACK_E2E_LIVE_WRITE: "1" }, expected: [] },
+    { label: "PSTACK_E2E_LIVE=1 with a residual write, a clone and the repository of the current checkout", env: { ...named, PSTACK_E2E_LIVE_WRITE: "1", PSTACK_E2E_LIVE_CLONE: join(root, "absent-clone-2") }, origin: REPO, expected: [CHECKOUT_PROBE] },
+  ];
+  try {
+    for (const [index, row] of rows.entries()) {
+      await t.test(row.label, { timeout: 120_000 }, () => {
+        const checkout = join(root, `checkout-${index}`);
+        if (row.origin) initFixtureRepo(checkout, `https://github.com/${row.origin}.git`);
+        rmSync(probe, { force: true });
+        const run = spawnSync(process.execPath, ["--experimental-strip-types", "--test", "--test-reporter=tap", liveFile], {
+          cwd: row.origin ? checkout : process.cwd(), encoding: "utf8", env: matrixEnv(row.env, preload, probe),
+        });
+        assert.equal(run.status, 0, `${row.label}\n${run.stdout}${run.stderr}`);
+        assert.match(run.stdout, /^# skipped 3$/m, row.label);
+        assert.match(run.stdout, /^# fail 0$/m, row.label);
+        assert.deepEqual(observedCommands(probe), row.expected, `${row.label} ran an unexpected external command`);
+      });
+    }
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});
+
+test(`${OFFLINE} every test in the live tier consults only the guard gate`, () => {
+  const files = readdirSync(join("test", "live")).filter((name) => name.endsWith(".test.ts"));
+  assert.equal(files.includes("github-live.test.ts"), true);
+  for (const file of files) {
+    const source = readFileSync(join("test", "live", file), "utf8");
+    const tests = source.match(/\btest\(/g) ?? [];
+    const gates = source.match(/skip:\s*(\w+)\.skip/g) ?? [];
+    assert.equal(tests.length > 0, true, `${file} declares no test`);
+    assert.equal(gates.length, tests.length, `${file} must gate every test with a guard skip`);
+    assert.equal(/process\.env\.PSTACK_E2E_LIVE/.test(source), false, `${file} must not read the live environment directly`);
+    assert.equal(/\bliveTarget\(/.test(source), false, `${file} must not consult the raw target`);
+    for (const gate of gates) {
+      const name = gate.replace(/^skip:\s*/, "").replace(/\.skip$/, "");
+      assert.match(source, new RegExp(`const ${name} = liveTier\\(`), `${file} must derive ${name} from liveTier`);
+    }
+  }
+});
+
+test(`${OFFLINE} GitHubCLI rejects invalid repository and pull request inputs before it touches gh`, async () => {
+  const provider = new GitHubCLI();
+  await assert.rejects(provider.read("not a repository", 1), /Invalid GitHub PR/);
+  await assert.rejects(provider.read("owner/name", 0), /Invalid GitHub PR/);
+  await assert.rejects(provider.read("owner/name", 1.5), /Invalid GitHub PR/);
+});
+
+test(`${OFFLINE} the GitHub provider refuses a merge whose expected head is stale`, { timeout: 60_000 }, async () => {
+  const server = await startGitHubServer("passed", "approved");
+  try {
+    server.views.set(1, { number: 1, headSha: "b".repeat(40), baseSha: "a".repeat(40), baseRef: "main", state: "OPEN", draft: false, mergeState: "CLEAN", mergeable: "MERGEABLE", ci: "passed", review: "approved" });
+    const client = githubClient(server.port);
+    await assert.rejects(client.merge({ number: 1, headSha: "c".repeat(40) }), /HEAD_MOVED/);
+    assert.equal(server.views.get(1)!.state, "OPEN");
+    await client.merge({ number: 1, headSha: "b".repeat(40) });
+    assert.equal(server.views.get(1)!.state, "MERGED");
+    assert.equal(server.calls.filter((call) => call.op === "merge").length, 2);
+  } finally { await server.close(); }
+});
+
+test(`${OFFLINE} a disposable fixture repository never carries credentials in captured output`, () => {
+  const captured = redactCaptured(`cloning https://ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@github.com/${REPO}.git`);
+  assert.equal(captured.includes("ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"), false);
+  assert.equal(captured.includes(`https://[REDACTED]@github.com/${REPO}.git`), true);
+  const root = mkdtempSync(join(process.cwd(), ".e2e-offline-"));
+  try {
+    const head = initFixtureRepo(join(root, "checkout"), `https://github.com/${REPO}.git`);
+    assert.match(head, /^[0-9a-f]{40}$/);
+    assert.equal(git(join(root, "checkout"), ["remote", "get-url", "origin"]), `https://github.com/${REPO}.git`);
+    assert.equal(existsSync(join(root, "checkout", "base.txt")), true);
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});

package/test/e2e/parent-context.ts

@@ -0,0 +1,66 @@
+import { createAgentSession, DefaultResourceLoader, ModelRegistry, SessionManager } from "@earendil-works/pi-coding-agent";
+import { fingerprint } from "../../src/artifacts/fingerprint.ts";
+import type { TaskBrief } from "../../src/contracts/types.ts";
+import type { WorkflowRunSpec } from "../../src/runtime/types.ts";
+import { MODEL, writeModelConfig } from "./harness.ts";
+
+export const GATE_ALPHA = ["node", "-e", "process.exit(require('fs').readFileSync('alpha.txt','utf8').trim()==='alpha'?0:1)"];
+export const GATE_BETA = ["node", "-e", "process.exit(require('fs').readFileSync('beta.txt','utf8').trim()==='beta'?0:1)"];
+export const GATE_INTEGRATED = ["node", "-e", "process.exit(require('fs').readFileSync('alpha.txt','utf8').trim()==='alpha'&&require('fs').readFileSync('beta.txt','utf8').trim()==='beta'?0:1)"];
+export const GATE_COMMANDS = [GATE_ALPHA, GATE_BETA, GATE_INTEGRATED];
+
+export function strictBrief(id: string, repoId: string, goal: string, include: string[], command: string[]): TaskBrief {
+  return {
+    id, revision: 1, contractLevel: "strict", goal,
+    scope: { include, exclude: [], repoId },
+    contextRefs: [],
+    acceptance: [{ id: `${id}-ac`, description: "the artifact gate passes on the real checkout", required: true, gateIds: [`${id}-gate`] }],
+    verification: [{ id: `${id}-gate`, kind: "command", command, sideEffect: "none", category: "behavior", required: true }],
+    timeboxSeconds: 300, forbidden: [], standingOrders: [], reportFormat: "task-report-v1",
+  };
+}
+
+export function strictWorkflowSpec(cwd: string, parentSessionId?: string): WorkflowRunSpec {
+  const repoId = fingerprint(cwd).repoId;
+  return {
+    name: "e2e-strict-integration",
+    type: "graph",
+    contractLevel: "strict",
+    maxConcurrency: 2,
+    cwd,
+    ...(parentSessionId ? { parentSessionId } : {}),
+    nodes: [
+      { key: "alpha", profile: "worker", isolation: "worktree", task: "TASK:alpha write the alpha artifact", brief: strictBrief("e2e-alpha", repoId, "write alpha.txt", ["alpha.txt"], GATE_ALPHA) },
+      { key: "beta", profile: "worker", isolation: "worktree", task: "TASK:beta write the beta artifact", brief: strictBrief("e2e-beta", repoId, "write beta.txt", ["beta.txt"], GATE_BETA) },
+      { key: "integrate", profile: "integrator", dependsOn: ["alpha", "beta"], task: "TASK:integrate combine both artifacts into the target checkout", brief: strictBrief("e2e-integrate", repoId, "integrate both artifacts", ["alpha.txt", "beta.txt"], GATE_INTEGRATED) },
+      { key: "check", profile: "verifier", dependsOn: ["integrate"], task: "TASK:check verify the integrated artifact", brief: strictBrief("e2e-check", repoId, "verify the integrated checkout", ["**"], GATE_INTEGRATED) },
+    ],
+  };
+}
+
+export interface ParentContext {
+  session: any;
+  ctx: any;
+  dispose(): void;
+}
+
+export const SIGKILL_SESSION_ID = "e2e-sigkill-parent";
+
+export async function openParentContext(options: { agentDir: string; cwd: string; modelPort: number; sessionDir?: string; sessionId?: string; modelIds?: string[] }): Promise<ParentContext> {
+  process.env.PI_CODING_AGENT_DIR = options.agentDir;
+  writeModelConfig(options.agentDir, options.modelPort, options.modelIds);
+  const loader = new DefaultResourceLoader({
+    cwd: options.cwd, agentDir: options.agentDir,
+    noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true,
+  });
+  await loader.reload();
+  const manager = SessionManager.create(options.cwd, options.sessionDir, options.sessionId ? { id: options.sessionId } : undefined);
+  const { session } = await createAgentSession({
+    cwd: options.cwd, agentDir: options.agentDir, thinkingLevel: "off",
+    sessionManager: manager, resourceLoader: loader, tools: [], customTools: [],
+  });
+  const model = session.modelRuntime.getModel("loopback", MODEL);
+  if (!model) throw new Error("the loopback model is not configured");
+  const ctx = { sessionManager: session.sessionManager, modelRegistry: new ModelRegistry(session.modelRuntime), model, thinkingLevel: "off" as const, scopedModels: [] };
+  return { session, ctx, dispose: () => session.dispose() };
+}

package/test/e2e/reported-defects.test.ts

@@ -0,0 +1,85 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { AgentHost } from "../../src/agent/host.ts";
+import { fingerprint } from "../../src/artifacts/fingerprint.ts";
+import { protocol } from "../../src/runtime/protocol.ts";
+import { verify } from "../../src/verification/runner.ts";
+import { OFFLINE, initFixtureRepo, startModelServer, toolResultText, writeVerificationPolicy } from "./harness.ts";
+import { openParentContext, type ParentContext } from "./parent-context.ts";
+
+const READ_ONLY = ["find", "grep", "ls", "pstack_evidence", "pstack_skill", "read"];
+
+test(`${OFFLINE} reported src defect: read-only child profiles receive no read-only tools`, {}, async () => {
+  const root = mkdtempSync(join(process.cwd(), ".e2e-defect-tools-"));
+  const home = join(root, "pstack");
+  const agentDir = join(root, "pi-agent");
+  const checkout = join(root, "checkout");
+  const previousHome = process.env.PSTACK_NATIVE_HOME;
+  const previousAgentDir = process.env.PI_CODING_AGENT_DIR;
+  process.env.PSTACK_NATIVE_HOME = home;
+  mkdirSync(home, { recursive: true });
+  initFixtureRepo(checkout, "https://github.com/loopback-owner/lemn-disposable.git");
+  const model = await startModelServer(call => {
+    if(call.step===0)return {tool:{name:"pstack_skill",args:{action:"read",resource:"how/SKILL.md"}}};
+    if(call.step===1)return {tool:{name:"pstack_evidence",args:{category:"issues"}}};
+    if(call.step===2)return {tool:{name:"read",args:{path:join(root,"outside.txt")}}};
+    return {text:"Bundled skill inspected; issue snapshot supplied; outside read refused."};
+  });
+  let parent: ParentContext | undefined;
+  try {
+    parent = await openParentContext({ agentDir, cwd: checkout, modelPort: model.port, sessionDir: join(root, "parent-sessions") });
+    const host = new AgentHost();
+    writeFileSync(join(root,"outside.txt"),"PRIVATE_OUTSIDE_DATA");
+    const evidencePackets:any[]=[{category:"issues",status:"available",reason:"authorized parent query",items:[{source:"https://github.com/test/repo/issues/1",observedAt:"2026-10-14T00:00:00Z",excerpt:"Issue snapshot supplied by parent."}]}];
+    const started = host.start({ evidencePackets, profile: "reviewer", task: "TASK:readonly inspect the assigned checkout", cwd: checkout }, parent.ctx);
+    const done = await host.wait(started.id);
+    assert.equal(done?.state, "completed", done?.error?.message);
+    const active = [...new Set(model.calls.flatMap((call) => call.tools))].sort();
+    assert.deepEqual(active, READ_ONLY, "a read-only child must be able to inspect its own checkout");
+    const observed=model.calls.map(c=>toolResultText(c.messages)).join("\n");
+    assert.match(observed, /"resource":\s*"how\/SKILL\.md"/);
+    assert.ok(observed.includes("# How"));
+    assert.ok(observed.includes("Issue snapshot supplied by parent."));
+    assert.ok(observed.includes("escapes child workspace"));
+    assert.ok(!observed.includes("PRIVATE_OUTSIDE_DATA"));
+    assert.equal(active.some((name) => ["bash", "edit", "write", "powershell"].includes(name)), false);
+  } finally {
+    parent?.dispose();
+    await model.close();
+    if (previousHome === undefined) delete process.env.PSTACK_NATIVE_HOME; else process.env.PSTACK_NATIVE_HOME = previousHome;
+    if (previousAgentDir === undefined) delete process.env.PI_CODING_AGENT_DIR; else process.env.PI_CODING_AGENT_DIR = previousAgentDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test(`${OFFLINE} reported src defect: a captured evidence log leaks a credential embedded in a URL`, {}, async () => {
+  const root = mkdtempSync(join(process.cwd(), ".e2e-defect-redact-"));
+  const home = join(root, "pstack");
+  const checkout = join(root, "checkout");
+  const previous = process.env.PSTACK_NATIVE_HOME;
+  process.env.PSTACK_NATIVE_HOME = home;
+  try {
+    mkdirSync(home, { recursive: true });
+    initFixtureRepo(checkout, "https://github.com/loopback-owner/lemn-disposable.git");
+    const leaked = "ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    const script = `process.stdout.write(['https://${leaked}@github.com/owner/name.git','bare ${leaked}','GITHUB_TOKEN=${leaked}','Authorization: Bearer ${leaked}'].join('\\n'))`;
+    const command = ["node", "-e", script];
+    writeVerificationPolicy(home, [command]);
+    const repoId = fingerprint(checkout, "committed").repoId;
+    const ledger = await verify(checkout, {
+      id: "e2e-redaction", revision: 1, contractLevel: "minimal", goal: "capture a log",
+      scope: { include: ["**"], exclude: [], repoId }, contextRefs: [], acceptance: [],
+      verification: [{ id: "g1", kind: "command", command, sideEffect: "none", category: "behavior", required: true }],
+      forbidden: [], standingOrders: [], reportFormat: "task-report-v1",
+    });
+    const log = readFileSync(protocol().evidence[ledger.evidenceRefs[0]!]!.logPath, "utf8");
+    assert.equal(log.includes(leaked), false, `the evidence log still contains the credential: ${log}`);
+    assert.match(log, /GITHUB_TOKEN=\[REDACTED\]/);
+    assert.match(log, /https:\/\/\[REDACTED\]@github\.com/);
+  } finally {
+    if (previous === undefined) delete process.env.PSTACK_NATIVE_HOME; else process.env.PSTACK_NATIVE_HOME = previous;
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/test/e2e/shipping.test.ts

@@ -0,0 +1,204 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fingerprint } from "../../src/artifacts/fingerprint.ts";
+import { verify } from "../../src/verification/runner.ts";
+import { preparePR, openPreparedPR } from "../../src/delivery/prepare.ts";
+import { refresh, eligibility, authorizeMerge, ship } from "../../src/delivery/frontier.ts";
+import { protocol, type ProtocolState } from "../../src/runtime/protocol.ts";
+import type { TaskReport } from "../../src/contracts/types.ts";
+import { FAKE_PROVIDER, git, githubClient, initFixtureRepo, post, startGitHubServer, writeVerificationPolicy, spawnChild } from "./harness.ts";
+
+const REMOTE = "https://github.com/loopback-owner/lemn-disposable.git";
+const REPO = "loopback-owner/lemn-disposable";
+const GATE = ["node", "-e", "process.exit(require('fs').readFileSync('change.txt','utf8').trim()==='change'?0:1)"];
+
+interface Fixture {
+  root: string; home: string; checkout: string; repoId: string; baseSha: string; headSha: string;
+  restoreEnv(): void; dispose(): void;
+}
+
+function fixture(): Fixture {
+  const root = mkdtempSync(join(process.cwd(), ".e2e-ship-"));
+  const home = join(root, "pstack");
+  const checkout = join(root, "checkout");
+  mkdirSync(home, { recursive: true });
+  const previous = process.env.PSTACK_NATIVE_HOME;
+  process.env.PSTACK_NATIVE_HOME = home;
+  const baseSha = initFixtureRepo(checkout, REMOTE);
+  const repoId = fingerprint(checkout, "committed").repoId;
+  git(checkout, ["checkout", "-q", "-b", "feature/e2e"]);
+  writeFileSync(join(checkout, "change.txt"), "change\n");
+  git(checkout, ["add", "-A"]);
+  git(checkout, ["commit", "-qm", "change"]);
+  const headSha = git(checkout, ["rev-parse", "HEAD"]);
+  writeVerificationPolicy(home, [GATE]);
+  return {
+    root, home, checkout, repoId, baseSha, headSha,
+    restoreEnv() { if (previous === undefined) delete process.env.PSTACK_NATIVE_HOME; else process.env.PSTACK_NATIVE_HOME = previous; },
+    dispose() { rmSync(root, { recursive: true, force: true }); },
+  };
+}
+
+function brief(f: Fixture) {
+  return {
+    id: "e2e-brief", revision: 1, contractLevel: "strict" as const, goal: "ship the verified commit",
+    scope: { include: ["change.txt"], exclude: [], repoId: f.repoId },
+    contextRefs: [], acceptance: [{ id: "ac1", description: "the change is shipped", required: true, gateIds: ["g1"] }],
+    verification: [{ id: "g1", kind: "command" as const, command: GATE, sideEffect: "none" as const, category: "behavior" as const, required: true }],
+    timeboxSeconds: 300, forbidden: [], standingOrders: [], reportFormat: "task-report-v1" as const,
+  };
+}
+
+function report(f: Fixture): TaskReport {
+  return { status: "completed", artifactRefs: [], base: f.baseSha, head: f.headSha, commandsRun: [GATE], evidenceRefs: [], deviations: [], unresolved: [], nextActions: [] };
+}
+
+async function verifiedLedger(f: Fixture, number: number) {
+  return await verify(f.checkout, brief(f), { pr: { repoId: f.repoId, number, headSha: f.headSha, baseSha: f.baseSha }, report: report(f) });
+}
+
+function spec(f: Fixture, number = 1) {
+  return { id: `e2e-ship-${number}`, repoId: f.repoId, repo: REPO, numbers: [number], owner: "e2e-operator", rootBase: "main" };
+}
+
+function events(): ProtocolState["events"] {
+  return protocol().events;
+}
+
+test(`${FAKE_PROVIDER} a verified commit opens a pull request and its base, head, CI and review state are read back`, { timeout: 60_000 }, async () => {
+  const f = fixture();
+  const server = await startGitHubServer("passed", "approved");
+  server.branches.set("main", f.baseSha);
+  try {
+    const ledger = await verifiedLedger(f, 1);
+    assert.equal(ledger.status, "passed");
+    assert.equal(ledger.contractAccepted, true);
+
+    const plan = preparePR(f.checkout, ledger.id, { repo: REPO, base: "main", head: "feature/e2e", title: "e2e verified change" });
+    assert.equal(plan.headSha, f.headSha);
+
+    server.branches.set("feature/e2e", "f".repeat(40));
+    await assert.rejects(openPreparedPR(f.checkout, plan, githubClient(server.port) as never, true), /REMOTE_BRANCH_NOT_VERIFIED/);
+    assert.equal(server.views.size, 0, "an unverified remote head must not open a pull request");
+
+    server.branches.set("feature/e2e", f.headSha);
+    const opened = await openPreparedPR(f.checkout, plan, githubClient(server.port) as never, true) as { url: string };
+    assert.match(opened.url, /\/pull\/1$/);
+    assert.deepEqual(server.calls.filter((call) => call.op === "branch").slice(-1).map((call) => call.detail), ["feature/e2e"]);
+    assert.deepEqual(server.calls.filter((call) => call.op === "open").map((call) => call.detail), ["1 main<-feature/e2e"]);
+
+    const frontier = await refresh(spec(f), githubClient(server.port));
+    const pr = frontier.prs[0]!;
+    assert.equal(pr.baseRef, "main");
+    assert.equal(pr.baseSha, f.baseSha);
+    assert.equal(pr.headSha, f.headSha);
+    assert.equal(pr.state, "OPEN");
+    assert.equal(pr.ci, "passed");
+    assert.equal(pr.review, "approved");
+    assert.equal(pr.mergeable, "MERGEABLE");
+    assert.deepEqual(eligibility(frontier), [{ number: 1, eligible: true, blockers: [] }]);
+  } finally {
+    await server.close();
+    f.restoreEnv(); f.dispose();
+  }
+});
+
+test(`${FAKE_PROVIDER} a stale head SHA blocks the merge`, { timeout: 60_000 }, async () => {
+  const f = fixture();
+  const server = await startGitHubServer("passed", "approved");
+  try {
+    await verifiedLedger(f, 1);
+    server.branches.set("main", f.baseSha);
+    server.branches.set("feature/e2e", f.headSha);
+    server.views.set(1, { number: 1, headSha: f.headSha, baseSha: f.baseSha, baseRef: "main", state: "OPEN", draft: false, mergeState: "CLEAN", mergeable: "MERGEABLE", ci: "passed", review: "approved" });
+
+    const client = githubClient(server.port);
+    const frontier = await refresh(spec(f), client);
+    const token = authorizeMerge(frontier, 1, "human-cli");
+
+    const movedHead = "a".repeat(40);
+    server.views.get(1)!.headSha = movedHead;
+    await assert.rejects(ship(spec(f), client, { token, dryRun: false }), /AUTHORIZATION_MISSING_OR_STALE/);
+    assert.equal(server.calls.filter((call) => call.op === "merge").length, 0, "a moved head must not reach the merge call");
+
+    const reauthorized = authorizeMerge(await refresh(spec(f), client), 1, "human-cli");
+    await assert.rejects(ship(spec(f), client, { token: reauthorized, dryRun: false }), /SHIPPING_BLOCKED/);
+    assert.equal(server.calls.filter((call) => call.op === "merge").length, 0);
+    assert.equal(eligibility(await refresh(spec(f), client))[0]!.blockers.includes("CURRENT_VERIFICATION_REQUIRED"), true);
+
+    const rejected = await post(server.port, "/merge", { number: 1, headSha: f.headSha });
+    assert.equal(rejected.status, 409, "the provider rejects a merge whose expected head is stale");
+  } finally {
+    await server.close();
+    f.restoreEnv(); f.dispose();
+  }
+});
+
+test(`${FAKE_PROVIDER} a crash before the external side effect replays exactly once and never double-merges`, { timeout: 90_000 }, async () => {
+  const f = fixture();
+  const server = await startGitHubServer("passed", "approved");
+  try {
+    await verifiedLedger(f, 1);
+    server.branches.set("main", f.baseSha);
+    server.branches.set("feature/e2e", f.headSha);
+    server.views.set(1, { number: 1, headSha: f.headSha, baseSha: f.baseSha, baseRef: "main", state: "OPEN", draft: false, mergeState: "CLEAN", mergeable: "MERGEABLE", ci: "passed", review: "approved" });
+    const token = authorizeMerge(await refresh(spec(f), githubClient(server.port)), 1, "human-cli");
+
+    const child = spawnChild(join(process.cwd(), "test", "e2e", "fixture-child.mjs"), ["ship", String(server.port), f.checkout, f.home, f.repoId, REPO, "1", token, "crash-before"], {});
+    const exited = await child.exit;
+    assert.equal(exited.signal, "SIGKILL");
+    assert.equal(server.views.get(1)!.state, "OPEN", "the remote never applied the merge");
+    assert.equal(server.calls.filter((call) => call.op === "merge").length, 0);
+    assert.equal(events().some((event) => event.type === "merge-requested"), true, "the intent was durably recorded before the crash");
+    assert.equal(events().some((event) => event.type === "merge-confirmed"), false);
+
+    const replay = authorizeMerge(await refresh(spec(f), githubClient(server.port)), 1, "human-cli");
+    const before = server.calls.length;
+    const merged = await ship(spec(f), githubClient(server.port), { token: replay, dryRun: false }) as { merged: number };
+    const recovery = server.calls.slice(before);
+    assert.equal(recovery[0]!.op, "read", "recovery reads the remote state before any replay");
+    assert.equal(merged.merged, 1);
+    assert.equal(server.views.get(1)!.state, "MERGED");
+    assert.equal(server.calls.filter((call) => call.op === "merge").length, 1, "exactly one merge reached the provider");
+  } finally {
+    await server.close();
+    f.restoreEnv(); f.dispose();
+  }
+});
+
+test(`${FAKE_PROVIDER} a crash after the external side effect is at most once because recovery reads the remote first`, { timeout: 90_000 }, async () => {
+  const f = fixture();
+  const server = await startGitHubServer("passed", "approved");
+  try {
+    await verifiedLedger(f, 1);
+    server.branches.set("main", f.baseSha);
+    server.branches.set("feature/e2e", f.headSha);
+    server.views.set(1, { number: 1, headSha: f.headSha, baseSha: f.baseSha, baseRef: "main", state: "OPEN", draft: false, mergeState: "CLEAN", mergeable: "MERGEABLE", ci: "passed", review: "approved" });
+    const token = authorizeMerge(await refresh(spec(f), githubClient(server.port)), 1, "human-cli");
+
+    const child = spawnChild(join(process.cwd(), "test", "e2e", "fixture-child.mjs"), ["ship", String(server.port), f.checkout, f.home, f.repoId, REPO, "1", token, "crash-after"], {});
+    const exited = await child.exit;
+    assert.equal(exited.signal, "SIGKILL");
+    assert.equal(server.views.get(1)!.state, "MERGED", "the remote applied the merge before the crash");
+    assert.equal(server.calls.filter((call) => call.op === "merge").length, 1);
+    assert.equal(events().some((event) => event.type === "merge-confirmed"), false, "the crash happened before confirmation was recorded");
+
+    const before = server.calls.length;
+    await assert.rejects(ship(spec(f), githubClient(server.port), { token, dryRun: false }), /AUTHORIZATION_MISSING_OR_STALE/);
+    assert.equal(server.calls.slice(before)[0]!.op, "read", "the consumed-authorization path still reads the remote first");
+    assert.equal(server.calls.filter((call) => call.op === "merge").length, 1, "the merge is not replayed");
+
+    const reauthorized = authorizeMerge(await refresh(spec(f), githubClient(server.port)), 1, "human-cli");
+    await assert.rejects(ship(spec(f), githubClient(server.port), { token: reauthorized, dryRun: false }), /SHIPPING_BLOCKED/);
+    assert.equal(server.calls.filter((call) => call.op === "merge").length, 1, "a re-authorized replay is blocked by the merged remote state");
+
+    const dry = await ship(spec(f), githubClient(server.port)) as { decisions: { blockers: string[] }[] };
+    assert.deepEqual(dry.decisions[0]!.blockers, ["ALREADY_MERGED"]);
+    assert.equal(server.calls.filter((call) => call.op === "merge").length, 1);
+  } finally {
+    await server.close();
+    f.restoreEnv(); f.dispose();
+  }
+});