pi-session-mcp 0.8.3 → 0.12.0

package/docs/evaluation/tool-definitions-2026-10-18/compare-validation.mjs

@@ -0,0 +1,64 @@
+// Drives the built server (dist/server.js) in memory with a counting fake adapter and records the exact JSON-RPC
+// response of 156 input cases (26 values x 6 UUID fields) plus whether any call touched session state.
+// usage: node compare-validation.mjs <checkoutRoot-with-dist-and-node_modules> <out.json>
+import { join } from "node:path";
+import { writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+const root = process.argv[2], out = process.argv[3];
+const { createServer } = await import(pathToFileURL(join(root, "dist/server.js")).href);
+const { SessionRegistry } = await import(pathToFileURL(join(root, "dist/session-registry.js")).href);
+const { InMemoryTransport } = await import(pathToFileURL(join(root, "node_modules/@modelcontextprotocol/client/dist/index.mjs")).href);
+const calls = [];
+const adapter = { async create(input) { calls.push("create"); return {
+  sdkSessionId: "fake", appliedSelection: { provider: "p", model: "m", thinkingLevel: "off" },
+  prompt(_t, preflight) { calls.push("prompt"); preflight(true); return new Promise(() => {}); },
+  async abort() { calls.push("abort"); }, dispose() { calls.push("dispose"); } }; } };
+const workspaces = new Map([["repo", "/safe/repo"]]);
+const profile = { alias: "safe", default: true, permissionProfile: "read-only", provider: "p", model: "m", thinkingLevel: "off" };
+const registry = new SessionRegistry(adapter, workspaces, {});
+const server = createServer(registry, workspaces, new Map([["safe", profile]]), "safe", { fingerprint: "sha256:" + "0".repeat(64), reloadPolicy: "restart-required" });
+const [ct, st] = InMemoryTransport.createLinkedPair();
+const inbox = []; ct.onmessage = m => inbox.push(m);
+await server.connect(st); await ct.start();
+let id = 0;
+const rpc = async (method, params) => { const n = ++id; await ct.send({ jsonrpc: "2.0", id: n, method, params }); for (let i = 0; i < 500 && !inbox.find(m => m.id === n); i++) await new Promise(r => setTimeout(r, 2)); return JSON.stringify(inbox.find(m => m.id === n)); };
+await rpc("initialize", { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "c", version: "1" } });
+await ct.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+const call = (name, args) => rpc("tools/call", { name, arguments: args });
+// one live session + running turn so that side effects would be visible
+const started = JSON.parse(JSON.parse(await call("pi_session_start", { workspace: "repo" })).result.content[0].text);
+const sid = started.session.id;
+const prompted = JSON.parse(JSON.parse(await call("pi_session_prompt", { sessionId: sid, prompt: "x" })).result.content[0].text);
+const tid = prompted.turn.turnId;
+const res = async (n, a) => JSON.stringify(JSON.parse(await call(n, a)).result);
+const snapshot = async () => ({ list: await res("pi_session_list", {}), turn: await res("pi_turn_get", { sessionId: sid, turnId: tid }), session: await res("pi_session_get", { sessionId: sid }), calls: calls.length });
+const normalize = s => s.replaceAll(sid, "<SID>").replaceAll(tid, "<TID>").replace(/\d{4}-\d\d-\d\dT[\d:.]+Z/g, "<TS>");
+const unknownA = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", unknownB = "bbbbbbbb-bbbb-4bbb-9bbb-bbbbbbbbbbbb";
+const values = [
+  ["unknown valid v4", unknownA], ["unknown valid v8 variant b", unknownB], ["nil", "00000000-0000-0000-0000-000000000000"],
+  ["max", "ffffffff-ffff-ffff-ffff-ffffffffffff"], ["uppercase unknown", unknownA.toUpperCase()],
+  ["mixed case unknown", "AAAAAAAA-aaaa-4AAA-8aaa-aaaaaaaaaaaa"], ["version nibble 0", "aaaaaaaa-aaaa-0aaa-8aaa-aaaaaaaaaaaa"],
+  ["version nibble 9", "aaaaaaaa-aaaa-9aaa-8aaa-aaaaaaaaaaaa"], ["variant nibble 7", "aaaaaaaa-aaaa-4aaa-7aaa-aaaaaaaaaaaa"],
+  ["variant nibble c", "aaaaaaaa-aaaa-4aaa-caaa-aaaaaaaaaaaa"], ["too short", unknownA.slice(0, -1)], ["too long", unknownA + "a"],
+  ["no hyphens", unknownA.replaceAll("-", "")], ["braces", "{" + unknownA + "}"], ["non-hex", "gggggggg-aaaa-4aaa-8aaa-aaaaaaaaaaaa"],
+  ["leading space", " " + unknownA], ["trailing newline", unknownA + "\n"], ["empty", ""], ["plain text", "not-a-uuid"],
+  ["number", 1], ["null", null], ["boolean", true], ["object", {}], ["array", [unknownA]],
+  ["missing", undefined], ["nil-like upper", "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF"],
+];
+const fields = [["pi_session_get", "sessionId"], ["pi_session_prompt", "sessionId"], ["pi_session_abort", "sessionId"], ["pi_session_close", "sessionId"], ["pi_turn_get", "sessionId"], ["pi_turn_get", "turnId"]];
+const results = []; let sideEffects = 0;
+for (const [tool, field] of fields) for (const [label, value] of values) {
+  const args = { sessionId: field === "turnId" ? sid : unknownA, turnId: unknownB, prompt: "p" };
+  if (tool !== "pi_session_prompt") delete args.prompt;
+  if (tool !== "pi_turn_get") delete args.turnId;
+  if (value === undefined) delete args[field]; else args[field] = value;
+  const before = await snapshot(); const response = await call(tool, args); const after = await snapshot();
+  const touched = JSON.stringify(before) !== JSON.stringify(after); if (touched) sideEffects++;
+  results.push({ tool, field, label, args: normalize(JSON.stringify(args)), response: normalize(response), sideEffect: touched });
+}
+// valid known ids still work (read paths only; no close/abort of the live session before the end)
+const known = [await call("pi_session_get", { sessionId: sid }), await call("pi_turn_get", { sessionId: sid, turnId: tid })].map(normalize);
+const toolsList = await rpc("tools/list", {});
+writeFileSync(out, JSON.stringify({ results, known, sideEffects, toolsList: JSON.parse(toolsList).result.tools.map(t => ({ name: t.name, inputSchema: t.inputSchema, outputSchema: t.outputSchema, annotations: t.annotations })) }, null, 1));
+console.log(JSON.stringify({ cases: results.length, sideEffects, adapterCalls: calls.length }));
+await registry.shutdown(); process.exit(0);

package/docs/evaluation/tool-definitions-2026-10-18/diff-validation.mjs

@@ -0,0 +1,13 @@
+// usage: node diff-validation.mjs <baseline.json> <candidate.json>  (outputs of compare-validation.mjs)
+import { readFileSync } from "node:fs";
+const [a, b] = process.argv.slice(2).map(f => JSON.parse(readFileSync(f, "utf8")));
+const eq = (x, y) => JSON.stringify(x) === JSON.stringify(y);
+const stripPattern = s => JSON.parse(JSON.stringify(s, (k, v) => k === "pattern" && typeof v === "string" && v.startsWith("^([0-9a-fA-F]{8}") ? undefined : v));
+const count = t => { let n = 0; JSON.stringify(t.map(x => x.inputSchema), (k, v) => { if (k === "pattern") n++; return v; }); return n; };
+console.log(JSON.stringify({
+  cases: a.results.length, responsesIdentical: eq(a.results, b.results), knownReadsIdentical: eq(a.known, b.known),
+  sideEffects: [a.sideEffects, b.sideEffects],
+  outputSchemasAndAnnotationsIdentical: eq(a.toolsList.map(t => [t.name, t.outputSchema, t.annotations]), b.toolsList.map(t => [t.name, t.outputSchema, t.annotations])),
+  inputSchemasIdenticalExceptUuidPattern: eq(a.toolsList.map(t => stripPattern(t.inputSchema)), b.toolsList.map(t => t.inputSchema)),
+  patternsInInputSchemas: [count(a.toolsList), count(b.toolsList)],
+}, null, 1));

package/docs/evaluation/tool-definitions-2026-10-18/measure-wire.mjs

@@ -0,0 +1,31 @@
+// Measures tools/list wire bytes and the eight pi tool definitions of a BUILT checkout (dist/main.js).
+// usage: node measure-wire.mjs <checkoutRoot> <outJson>
+// Provider-free: the server never starts a Pi session; the configuration lives in a disposable temporary directory.
+import { spawn } from "node:child_process";
+import { writeFileSync, mkdtempSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const root = process.argv[2], out = process.argv[3];
+const temp = mkdtempSync(join(tmpdir(), "tool-definitions-"));
+const dir = join(temp, "ws"); mkdirSync(dir);
+const cfg = join(temp, "config.json");
+writeFileSync(cfg, JSON.stringify({ workspaces: { project: dir }, executionProfiles: { ro: { default: true, permissionProfile: "read-only", provider: "example-provider", model: "example-model", thinkingLevel: "low", skills: [] } } }));
+const child = spawn(process.execPath, [join(root, "dist/main.js")], { env: { PATH: process.env.PATH, PI_SESSION_MCP_CONFIG: cfg }, stdio: ["pipe", "pipe", "inherit"] });
+let buf = Buffer.alloc(0); const frames = [];
+child.stdout.on("data", d => { buf = Buffer.concat([buf, d]); let i; while ((i = buf.indexOf(10)) >= 0) { frames.push(buf.subarray(0, i + 1)); buf = buf.subarray(i + 1); } });
+const send = m => child.stdin.write(JSON.stringify(m) + "\n");
+const wait = async n => { while (frames.length < n) await new Promise(r => setTimeout(r, 20)); };
+send({ jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "m", version: "1" } } });
+await wait(1);
+send({ jsonrpc: "2.0", method: "notifications/initialized" });
+send({ jsonrpc: "2.0", id: 2, method: "tools/list" });
+await wait(2);
+child.stdin.end();
+const frame = frames[1]; const tools = JSON.parse(frame.toString()).result.tools;
+const B = v => Buffer.byteLength(JSON.stringify(v));
+const per = tools.map(t => ({ name: t.name, description_bytes: Buffer.byteLength(t.description), input_schema_bytes: B(t.inputSchema), projected_bytes: B({ name: t.name, description: t.description, inputSchema: t.inputSchema }), full_definition_bytes: B(t) }));
+const res = { initialize_frame_bytes: frames[0].length, tools_list_frame_bytes: frame.length, tools_array_bytes: B(tools),
+  projected_name_description_inputSchema_total: per.reduce((n, p) => n + p.projected_bytes, 0),
+  projected_array_bytes: B(tools.map(t => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }))),
+  description_total: per.reduce((n, p) => n + p.description_bytes, 0), per };
+writeFileSync(out, JSON.stringify(res, null, 2)); console.log(JSON.stringify({ ...res, per: undefined }));

package/docs/evaluation/worker-system-prompt-2026-10-26/README.md

@@ -0,0 +1,95 @@
+# Worker system-prompt probe — 2026-10-26
+
+## Question and answer
+
+Does `phase0ResourceLoaderOptions()` in `src/sdk-pi-adapter.ts` make workers use `phase-0-system-prompt-disabled` rather than Pi's default prompt?
+
+**No, in the observed Pi SDK 1.4.0 behavior.** The adapter-created session's effective initial system prompt contains Pi's default coding-assistant preamble, tool summaries, behavior rules, documentation guidance, workspace context, a selected-skill catalogue, and the working directory. The placeholder is absent. For each permission profile tested, the complete prompt string equals the one from a default resource loader in the same isolated workspace.
+
+## Method
+
+Run from the repository root:
+
+```sh
+npm run build
+node docs/evaluation/worker-system-prompt-2026-10-26/probe.mjs
+```
+
+The script creates and removes a temporary workspace containing:
+
+- A small `AGENTS.md` with heading `# Probe workspace` and marker `WORKSPACE_CONTEXT_MARKER_26OCT`.
+- One skill with name `prompt-marker`, description marker `SKILL_DESCRIPTION_MARKER_26OCT`, and separate body marker `SKILL_BODY_MARKER_26OCT`.
+
+It clears inherited environment variables before importing Pi, isolates home/agent/auth/model-store locations, disables model refresh/network access, and installs network and child-process denial guards. An offline `ModelRuntime` registers a faux provider with a synthetic auth value, not a real provider credential. The provider throws if invoked. No turn, tool execution, or external provider request is made.
+
+The script builds real sessions through the compiled `SdkPiSessionAdapter`, using its injectable `createSession` boundary only to retain the returned public `AgentSession`. Both `read-only` and `coding` profiles select the skill through the adapter's normal skill-loading path. It reads **`session.systemPrompt`**, documented in Pi's `docs/sdk.md` as the current effective system prompt, including changes not yet sent to the model. Thus the observation is of public, runtime-constructed model-bound prompt state, not merely a reconstruction from source or a captured wire request.
+
+For comparison, it constructs `DefaultResourceLoader` with only `cwd`, `agentDir`, and in-memory `settingsManager`: no `systemPrompt`, overrides, or discovery-disable options. The same workspace, model, tool selection, in-memory session storage, and untrusted-project setting are used. The fixture resides in the agent directory's normal `skills/` discovery location, so default discovery finds exactly the same skill. The adapter itself uses the workspace as its agent directory. Assertions check one loaded skill, one context file, marker inclusion/exclusion, and complete prompt equality per profile.
+
+Only package-root SDK exports are imported. Installed implementation files were read afterward to explain the runtime result; no internal SDK import was needed. Diagnostics are suppressed, and stdout contains only a small, path-free JSON summary, never the complete prompt.
+
+## Environment
+
+- Base: `main` at `e6fc87c`; clean working tree verified before branching.
+- Repository direct Pi SDK dependency: `@earendil-works/pi-coding-agent` **1.4.0**, exactly pinned in root `package.json`; installed manifest also reports **1.4.0**.
+- Node: **v22.23.3**.
+- Linux; offline, credential-free session construction.
+
+## Observed results
+
+Character counts are JavaScript string lengths of the **actual effective prompt**, not normalized text. They include internally generated absolute paths, which are not printed. The temporary directory suffix has fixed length. Counts can differ in another installation because the SDK documentation paths and temporary-root length can differ.
+
+| Session | Profile | Characters | Placeholder | Default preamble | Context marker | Skill name / description / location | Skill body marker | Tool summaries / behavior rules |
+| --- | --- | ---: | --- | --- | --- | --- | --- | --- |
+| Adapter | read-only | 2991 | absent | present | present | present | absent | present |
+| Default loader | read-only | 2991 | absent | present | present | present | absent | present |
+| Adapter | coding | 3828 | absent | present | present | present | absent | present |
+| Default loader | coding | 3828 | absent | present | present | present | absent | present |
+
+In all four sessions:
+
+- Top-level structure, in order: untagged **preamble**, `<tools>`, `<rules>`, `<docs>`, `<project_context>`, `<skills>`, `<cwd>`.
+- The skill catalogue's `<available_skills>` is nested inside `<skills>`, not an additional top-level section.
+- The only Markdown heading is the fixture's `# Probe workspace` inside project context; Pi's own section boundaries use tags rather than Markdown headings.
+- The complete `read` tool description is **not** in this prompt text; its short `Read file contents` summary is. Do not confuse prompt summaries with full tool declarations and parameter schemas.
+- Active read-only tools: `find`, `grep`, `ls`, `read`. Active coding tools: `bash`, `edit`, `find`, `grep`, `ls`, `read`, `write`.
+- The adapter loader's public `getSystemPrompt()` returns `undefined`.
+
+The adapter/default prompts are byte-for-byte equal within each profile (string equality assertion). Two consecutive runs of the final script produced identical JSON (`cmp` exit 0). Both reported zero network attempts, zero child-process attempts, and zero provider calls.
+
+## Explanation from installed Pi implementation
+
+These references are relative to `node_modules/@earendil-works/pi-coding-agent/`. This distribution contains compiled implementation source in `dist/`, not the original `src/` files.
+
+1. **`dist/core/resource-loader.js`, `DefaultResourceLoader.reload()` (around lines 462–490):** after context-file loading, it resolves the configured system-prompt input into `baseSystemPrompt`, then assigns `this.systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(baseSystemPrompt) : baseSystemPrompt`. The adapter supplies a truthy callback that returns `undefined`. That return value **replaces** the placeholder; `undefined` does not mean “retain the original option.” The append override independently returns an empty array. Context loading is independent of this override and remains enabled.
+2. **`dist/core/agent-session.js`, `AgentSession._rebuildSystemPrompt()` (around lines 1287–1312):** it reads `resourceLoader.getSystemPrompt()` into `customPrompt`, gathers loaded skills/context files, and supplies selected tools, prompt snippets, and tool guidelines to the prompt builder. **`AgentSession.systemPrompt`** (around lines 1075–1078) renders the current effective options with `buildSystemPrompt()`.
+3. **`dist/core/system-prompt.js`, `buildSystemPromptSections()` and `buildSystemPrompt()`:** a truthy `customPrompt` replaces the default preamble/tool/rule/docs branch. With the observed `undefined`, Pi takes the default branch. It appends project context and the skill catalogue independently, adds the cwd, and renders tagged sections. `buildRules()` combines tool guidance with default concise-response/path-display rules.
+4. **`dist/core/skills.js`, `formatSkillsForPrompt()` (around lines 278–302):** advertises visible skills by name, description, and location, with instructions to load their files. It does not inline the skill body. The observed description marker present/body marker absent matches this design.
+5. **`dist/core/tools/read.js`, `readToolSystemPromptContribution` and `createReadToolDefinition()` (around lines 15–18 and 46–61):** the short prompt snippet and prompt guidelines are distinct from the full tool description/schema. **`dist/core/agent-session.js`, `_preparePromptAndToolLoadout()` (around lines 1315–1328)** builds prompt-section updates and notes that the agent loop separately declares tool changes before requests. Full declarations are therefore not accurately described as being embedded in the `session.systemPrompt` string; their request projection is a source-based explanation, not an observed provider call here.
+
+## Meaning for workers: facts versus inferences
+
+**Observed:** for the two extension-free adapter profiles, the initial effective prompt retains Pi's default coding/tool/behavior guidance. Workspace `AGENTS.md` content is included. Selected skill metadata and the file location are included, but the selected skill's instructions are not automatically inlined. The default-loader comparison is identical for this controlled workspace.
+
+**Inferred:** the placeholder is a resource-discovery suppression input, not the worker's effective system prompt. These workers do not lose Pi's default tool and behavior guidance because of that input. A skill still requires the model to read its file before its body can guide a task. The extension-session path uses the same `phase0ResourceLoaderOptions()` function, so its base construction should share this fallback; however, extensions can modify prompts or tool loadouts later, and this probe does not establish the final request for an arbitrary extension-enabled worker. It also does not claim every default-loader workspace is equivalent: ambient `SYSTEM.md`, append files, additional skills, or other discovered resources can change the default loader's result. No live worker/provider behavior or adherence was tested.
+
+Options, without a recommendation: retain the current behavior and document why the override returns `undefined`; simplify the placeholder/override arrangement only after checking discovery suppression remains intact; or introduce an explicit custom prompt if a later product decision calls for replacing Pi's defaults. This investigation changes none of those policies.
+
+## Checks
+
+| Command | Exit code | Result |
+| --- | ---: | --- |
+| `npm run build` | 0 | Compiled adapter used by probe |
+| `node docs/evaluation/worker-system-prompt-2026-10-26/probe.mjs` (final run 1) | 0 | All runtime assertions passed |
+| Same command (final run 2) | 0 | All runtime assertions passed |
+| `cmp /tmp/worker-prompt-run1.json /tmp/worker-prompt-run2.json` | 0 | Identical complete JSON summaries |
+| `npm run typecheck` | 0 | Green |
+
+No `src/` or test files were changed. No network, real mutation, provider-backed turn, or dogfooding result is claimed.
+
+Controller reproduction on the workstation host (outside the writer, Node
+26.12.1, Pi SDK 1.4.0): two runs exited 0 with identical output; adapter and
+default-loader prompts were equal per profile (2883 characters read-only, 3720
+coding; the difference from the counts above comes from the longer paths
+inside the writer), the placeholder was absent, and the probe saw zero network
+attempts and zero provider calls.

package/docs/evaluation/worker-system-prompt-2026-10-26/probe.mjs

@@ -0,0 +1,155 @@
+// Run after npm run build. Only documented package-root SDK exports are used.
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile, rm, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { syncBuiltinESMExports } from 'node:module';
+import net from 'node:net';
+import tls from 'node:tls';
+import http from 'node:http';
+import https from 'node:https';
+import dns from 'node:dns';
+import childProcess from 'node:child_process';
+
+const repo = resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
+const originalCwd = process.cwd();
+const originalEnv = { ...process.env };
+const scratch = await mkdtemp(join(tmpdir(), 'pi-prompt-probe-'));
+const cwd = join(scratch, 'workspace');
+const output = process.stdout.write.bind(process.stdout);
+let networkAttempts = 0;
+let childAttempts = 0;
+let providerCalls = 0;
+const denyNetwork = () => { networkAttempts++; throw new Error('offline_network_denied'); };
+const denyChild = () => { childAttempts++; throw new Error('offline_child_denied'); };
+globalThis.fetch = denyNetwork;
+if (typeof globalThis.WebSocket === 'function') globalThis.WebSocket = class { constructor() { denyNetwork(); } };
+net.Socket.prototype.connect = denyNetwork;
+net.connect = net.createConnection = tls.connect = denyNetwork;
+http.request = http.get = https.request = https.get = denyNetwork;
+dns.lookup = dns.resolve = dns.resolve4 = dns.resolve6 = dns.promises.lookup = denyNetwork;
+for (const key of ['spawn', 'spawnSync', 'exec', 'execSync', 'execFile', 'execFileSync', 'fork']) childProcess[key] = denyChild;
+syncBuiltinESMExports();
+// Isolate credentials and discovered resources before importing Pi.
+for (const key of Object.keys(process.env)) delete process.env[key];
+Object.assign(process.env, {
+  PATH: originalEnv.PATH ?? '', HOME: join(scratch, 'home'), TMPDIR: scratch,
+  XDG_CONFIG_HOME: join(scratch, 'config'), XDG_CACHE_HOME: join(scratch, 'cache'),
+  XDG_DATA_HOME: join(scratch, 'data'), PI_CODING_AGENT_DIR: cwd,
+});
+// Do not allow SDK diagnostics to leak paths or complete prompts.
+process.stdout.write = process.stderr.write = (_chunk, encoding, callback) => {
+  if (typeof encoding === 'function') encoding();
+  else if (typeof callback === 'function') callback();
+  return true;
+};
+let handle;
+let defaultSession;
+const deadline = setTimeout(() => { output('{"error":"probe_timeout"}\n'); process.exit(1); }, 30_000);
+try {
+  await mkdir(join(cwd, 'skills/prompt-marker'), { recursive: true });
+  await mkdir(process.env.HOME);
+  await writeFile(join(cwd, 'AGENTS.md'), '# Probe workspace\nWORKSPACE_CONTEXT_MARKER_26OCT\n');
+  const skillPath = join(cwd, 'skills/prompt-marker/SKILL.md');
+  await writeFile(skillPath, '---\nname: prompt-marker\ndescription: SKILL_DESCRIPTION_MARKER_26OCT\n---\n# Probe skill\nSKILL_BODY_MARKER_26OCT\n');
+  process.chdir(cwd);
+  const { ModelRuntime, DefaultResourceLoader, SettingsManager, SessionManager, createAgentSession } =
+    await import('@earendil-works/pi-coding-agent');
+  const { SdkPiSessionAdapter } = await import(pathToFileURL(join(repo, 'dist/sdk-pi-adapter.js')).href);
+  const sdkVersion = JSON.parse(await readFile(join(repo, 'node_modules/@earendil-works/pi-coding-agent/package.json'), 'utf8')).version;
+  const runtime = await ModelRuntime.create({
+    refreshOnCreate: false, allowModelNetwork: false, modelsPath: null,
+    authPath: join(scratch, 'absent-auth.json'), modelsStorePath: join(scratch, 'absent-models.json'),
+  });
+  // Faux provider satisfies the adapter's local model/auth checks; no turn is sent.
+  runtime.registerProvider('prompt-fixture', {
+    name: 'Offline prompt fixture', api: 'prompt-fixture-api', baseUrl: 'http://127.0.0.1:9', apiKey: 'not-a-credential',
+    models: [{ id: 'prompt-fixture-model', name: 'Fixture', reasoning: false, input: ['text'],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 32768, maxTokens: 1024 }],
+    streamSimple: () => { providerCalls++; throw new Error('provider_call_forbidden'); },
+  });
+  const model = runtime.getModel('prompt-fixture', 'prompt-fixture-model');
+  assert.ok(model);
+  const rows = [];
+  const prompts = new Map();
+  function summarize(kind, permissionProfile, session) {
+    // SDK docs/sdk.md: read-only current effective prompt, including unsent changes.
+    const prompt = session.systemPrompt;
+    // The skill catalogue has nested XML tags; it is not a separate prompt section.
+    const outer = prompt.replace(/<skills>[\s\S]*?<\/skills>/g, '<skills>');
+    const sections = ['preamble', ...[...outer.matchAll(/^<([a-z][a-z0-9_]*)>$/gm)].map(match => match[1])];
+    const row = {
+      kind, permissionProfile, characters: prompt.length, sections,
+      markdownHeadings: prompt.split('\n').filter(line => /^#{1,6} /.test(line)),
+      placeholder: prompt.includes('phase-0-system-prompt-disabled'),
+      defaultPreamble: prompt.startsWith('You are an expert coding assistant operating inside pi,'),
+      contextMarker: prompt.includes('WORKSPACE_CONTEXT_MARKER_26OCT'),
+      skillName: prompt.includes('<name>prompt-marker</name>'),
+      skillDescriptionMarker: prompt.includes('SKILL_DESCRIPTION_MARKER_26OCT'),
+      skillLocation: prompt.includes(skillPath),
+      skillBodyMarker: prompt.includes('SKILL_BODY_MARKER_26OCT'),
+      toolSummary: prompt.includes('- read: Read file contents'),
+      fullReadDescription: prompt.includes('Read the contents of a file. Supports text files and images'),
+      behaviorGuidance: prompt.includes('Be concise in your responses'),
+      activeTools: session.getActiveToolNames().sort(),
+      loadedSkills: session.resourceLoader.getSkills().skills.length,
+      contextFiles: session.resourceLoader.getAgentsFiles().agentsFiles.length,
+    };
+    assert.equal(row.placeholder, false);
+    for (const key of ['defaultPreamble', 'contextMarker', 'skillName', 'skillDescriptionMarker', 'skillLocation', 'toolSummary', 'behaviorGuidance']) assert.equal(row[key], true);
+    assert.equal(row.skillBodyMarker, false);
+    assert.equal(row.fullReadDescription, false);
+    assert.equal(row.loadedSkills, 1);
+    assert.equal(row.contextFiles, 1);
+    prompts.set(`${kind}:${permissionProfile}`, prompt);
+    rows.push(row);
+  }
+  for (const permissionProfile of ['read-only', 'coding']) {
+    let session;
+    const adapter = new SdkPiSessionAdapter({
+      modelRuntimeFactory: async () => runtime,
+      createSession: async options => {
+        const result = await createAgentSession(options);
+        session = result.session;
+        return result;
+      },
+    });
+    handle = await adapter.create({ cwd, executionProfile: {
+      alias: 'prompt-probe', permissionProfile, provider: model.provider, model: model.id, thinkingLevel: 'off',
+      extensions: [], skills: [{ alias: 'marker', path: skillPath }],
+    } });
+    assert.equal(session.resourceLoader.getSystemPrompt(), undefined);
+    summarize('adapter', permissionProfile, session);
+    const tools = session.getActiveToolNames();
+    await handle.dispose();
+    handle = undefined;
+    // Actual default loader options: no systemPrompt, overrides or discovery flags.
+    // Keep cwd, agentDir, in-memory settings and tools identical for a fair comparison.
+    const settingsManager = SettingsManager.inMemory(undefined, { projectTrusted: false });
+    const resourceLoader = new DefaultResourceLoader({ cwd, agentDir: cwd, settingsManager });
+    await resourceLoader.reload();
+    ({ session: defaultSession } = await createAgentSession({
+      cwd, agentDir: cwd, modelRuntime: runtime, model, thinkingLevel: 'off', tools,
+      resourceLoader, settingsManager, sessionManager: SessionManager.inMemory(cwd),
+    }));
+    summarize('default-loader', permissionProfile, defaultSession);
+    assert.equal(prompts.get(`adapter:${permissionProfile}`), prompts.get(`default-loader:${permissionProfile}`));
+    defaultSession.dispose();
+    defaultSession = undefined;
+  }
+  assert.equal(networkAttempts, 0);
+  assert.equal(childAttempts, 0);
+  assert.equal(providerCalls, 0);
+  output(`${JSON.stringify({ sdkVersion, nodeVersion: process.versions.node, rows,
+    adapterEqualsDefaultByProfile: true, networkAttempts, childAttempts, providerCalls })}\n`);
+} catch {
+  output(`${JSON.stringify({ error: 'probe_failed', networkAttempts, childAttempts, providerCalls })}\n`);
+  process.exitCode = 1;
+} finally {
+  clearTimeout(deadline);
+  if (handle) await handle.dispose().catch(() => undefined);
+  defaultSession?.dispose();
+  process.chdir(originalCwd);
+  await rm(scratch, { recursive: true, force: true });
+}