@xingular/harness 0.0.0-stage → 0.1.0

package/dist/terminal-pi.js

@@ -0,0 +1,326 @@
+// src/terminal/piExtension.ts
+import { Type } from "typebox";
+
+// src/terminal/client.ts
+import { createConnection } from "node:net";
+var SOCKET_ENV = "XINGULAR_HARNESS_SOCKET";
+var TOKEN_ENV = "XINGULAR_HARNESS_TOKEN";
+var SocketError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+function connectionFromEnv(env = process.env) {
+  const socket = env[SOCKET_ENV];
+  const token = env[TOKEN_ENV];
+  if (!socket || !token) throw new SocketError("not_configured", `This command only works inside a terminal session the harness started (${SOCKET_ENV} and ${TOKEN_ENV} are not set).`);
+  return { socket, token };
+}
+function request(connection, body, what, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const stream = createConnection(connection.socket);
+    let buffer = "";
+    let settled = false;
+    const finish = (action) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      stream.end();
+      action();
+    };
+    const timer = setTimeout(() => {
+      stream.destroy();
+      finish(() => reject(new SocketError("timeout", `The harness did not answer ${what}.`)));
+    }, timeoutMs);
+    stream.on("connect", () => stream.write(`${JSON.stringify({ token: connection.token, ...body })}
+`));
+    stream.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      const newline = buffer.indexOf("\n");
+      if (newline < 0) return;
+      try {
+        const reply = JSON.parse(buffer.slice(0, newline));
+        if (reply.error) {
+          const error = typeof reply.error === "string" ? { message: reply.error } : reply.error;
+          finish(() => reject(new SocketError(error.code ?? "error", error.message ?? `${what} failed.`)));
+        } else finish(() => resolve(reply.result));
+      } catch {
+        finish(() => reject(new SocketError("invalid_reply", "The harness sent an unreadable reply.")));
+      }
+    });
+    stream.on("error", (error) => finish(() => reject(new SocketError("unavailable", `The harness is not reachable: ${error.message}.`))));
+    stream.on("close", () => finish(() => reject(new SocketError("unavailable", "The harness closed the connection."))));
+  });
+}
+function socketCall(connection, call, params = {}, timeoutMs = 12e4, control) {
+  return request(connection, { call, params, ...control ? { control } : {} }, call, timeoutMs);
+}
+function terminalCall(event, data = {}, timeoutMs = 6e5) {
+  return request(connectionFromEnv(), { event, data }, event, timeoutMs);
+}
+
+// src/terminal/pluginMenu.ts
+var here = (attachment, projectId) => {
+  if (projectId && attachment.on.projectIds.includes(projectId)) return true;
+  if (projectId && attachment.off.projectIds.includes(projectId)) return false;
+  return attachment.global;
+};
+var mark = (on) => on ? "\u25CF" : "\u25CB";
+function menuRows(plugins, projectId) {
+  const rows = [];
+  for (const plugin of plugins) {
+    if (plugin.attachment) {
+      const on = here(plugin.attachment, projectId);
+      rows.push({ id: plugin.id, plugin, whole: true, on, label: `${mark(on)} ${plugin.title}${plugin.trust === "untrusted" ? " \xB7 code not trusted" : plugin.runsCode ? " \xB7 runs code" : ""}` });
+      continue;
+    }
+    if (plugin.trust !== "none") rows.push({ id: plugin.id, plugin, whole: true, on: plugin.trust === "trusted", label: `${mark(plugin.trust === "trusted")} ${plugin.title} \xB7 ${plugin.trust === "trusted" ? "code trusted" : "code not trusted"}` });
+    for (const entry of plugin.contributions) {
+      if (!entry.attachment) continue;
+      rows.push({ id: entry.id, plugin, whole: false, on: entry.state === "on", label: `${mark(entry.state === "on")} ${entry.name} \xB7 ${kindWord(entry)} in ${plugin.title}` });
+    }
+  }
+  return rows;
+}
+var kindWord = (entry) => entry.kind === "connection" ? "connected app" : entry.kind === "code" ? "extension" : entry.kind;
+var SWITCH_OFF_PROJECT = "Switch off for this project";
+var SWITCH_ON_PROJECT = "Switch on for this project";
+var SWITCH_OFF_EVERYWHERE = "Switch off everywhere";
+var SWITCH_ON_EVERYWHERE = "Switch on everywhere";
+var TRUST = "Trust its code";
+var UNTRUST = "Stop trusting its code";
+var BACK = "Back";
+var DONE = "Done";
+function rowActions(row, projectId) {
+  const switchable = row.whole ? row.plugin.attachment !== null : true;
+  const actions = [];
+  if (switchable) {
+    if (projectId) actions.push(row.on ? SWITCH_OFF_PROJECT : SWITCH_ON_PROJECT);
+    actions.push(row.on ? SWITCH_OFF_EVERYWHERE : SWITCH_ON_EVERYWHERE);
+  }
+  if (row.whole && row.plugin.code) actions.push(row.plugin.trust === "untrusted" ? TRUST : UNTRUST);
+  return [...actions, BACK];
+}
+async function runPluginsMenu(ui, call, projectId) {
+  let changed = false;
+  for (; ; ) {
+    const rows = menuRows(await call("plugins.list"), projectId);
+    if (!rows.length) {
+      ui.notify("There is nothing to switch or trust here yet.", "info");
+      return;
+    }
+    const picked = await ui.select(`Plugins${changed ? " (changes apply when this session restarts)" : ""}`, [...rows.map((row2) => row2.label), DONE]);
+    const row = rows.find((candidate) => candidate.label === picked);
+    if (!row) break;
+    const action = await ui.select(`${row.plugin.title}: ${row.plugin.description || "No description."}`, rowActions(row, projectId));
+    if (!action || action === BACK) continue;
+    try {
+      if (action === TRUST || action === UNTRUST) {
+        const code = row.plugin.code;
+        if (action === TRUST) {
+          const sure = await ui.confirm("Trust this code?", `${code.files.join("\n")}
+
+Fingerprint ${code.hash.slice(0, 12)}. It runs inside the session and can do anything this app can, including reading your files and credentials.`);
+          if (!sure) continue;
+        }
+        await call(action === TRUST ? "plugins.trust" : "plugins.untrust", { hash: code.hash });
+      } else {
+        const on = action === SWITCH_ON_PROJECT || action === SWITCH_ON_EVERYWHERE;
+        await call(on ? "plugins.attach" : "plugins.detach", { id: row.id, everywhere: action === SWITCH_ON_EVERYWHERE || action === SWITCH_OFF_EVERYWHERE });
+      }
+      changed = true;
+    } catch (error) {
+      ui.notify(error instanceof Error ? error.message : String(error), "error");
+    }
+  }
+  if (changed) ui.notify("Saved. It applies when this session restarts.", "info");
+}
+
+// src/terminal/piExtension.ts
+function resultSize(result) {
+  const content = result?.content;
+  if (!Array.isArray(content)) return typeof result === "string" ? result.length : null;
+  return content.reduce((total, part) => total + (part?.type === "text" && typeof part.text === "string" ? part.text.length : 0), 0);
+}
+async function piExtension_default(pi) {
+  await terminalCall("startup", { phase: "Pi extension loaded" });
+  let context = null;
+  let timer = null;
+  let polling = false;
+  let failure;
+  const emptyUsage = () => ({ inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, requests: 0, costUsd: 0 });
+  let usage = emptyUsage();
+  let reasoningTokens;
+  let costReported = false;
+  let requestStartedAt = null;
+  const toolStartedAt = /* @__PURE__ */ new Map();
+  const fileTools = /* @__PURE__ */ new Map();
+  let stage = "Tool discovery";
+  try {
+    await terminalCall("startup", { phase: stage });
+    const connection = connectionFromEnv();
+    const control = await socketCall(connection, "control.claim", {}, 15e3).then((claimed) => claimed.key).catch(() => null);
+    pi.registerCommand("plugins", {
+      description: "See what this session loads, and switch a plugin on or off or trust its code",
+      handler: async (_args, ctx) => {
+        if (!control) return ctx.ui.notify("This session cannot change plugins.", "warning");
+        const { projectId } = await socketCall(connection, "plugins.session", {}, 15e3, control).catch(() => ({ projectId: null }));
+        await runPluginsMenu(
+          { select: (title, options) => ctx.ui.select(title, options), confirm: (title, message) => ctx.ui.confirm(title, message), notify: (message, level) => ctx.ui.notify(message, level) },
+          (method, params) => socketCall(connection, method, params ?? {}, 6e4, control),
+          projectId
+        );
+      }
+    });
+    const { tools } = await socketCall(connection, "tools.list", {}, 15e3);
+    stage = "Tool registration";
+    for (const tool of tools) {
+      pi.registerTool({
+        name: tool.name,
+        label: tool.label,
+        description: tool.description,
+        parameters: Type.Unsafe(tool.parameters),
+        async execute(_id, input) {
+          const result = await socketCall(connection, "tools.call", { name: tool.name, input }, 123e4);
+          return { content: [{ type: "text", text: result.text }], details: void 0 };
+        }
+      });
+    }
+  } catch (error) {
+    await terminalCall("startupFailed", { reason: `${stage} failed: ${error instanceof Error ? error.message : "Unavailable"}` }).catch(() => {
+    });
+    throw error;
+  }
+  pi.on("session_start", async (_event, ctx) => {
+    context = ctx;
+    await terminalCall("ready", { nativeSessionId: ctx.sessionManager.getSessionFile() });
+    timer = setInterval(() => {
+      if (polling || !context) return;
+      polling = true;
+      void terminalCall("poll", {}, 5e3).then(({ command }) => {
+        if (command?.type === "interrupt") context?.abort();
+        else if (command?.type === "send") {
+          if (context?.ui.getEditorText().trim()) throw new Error("The terminal contains a user draft.");
+          pi.sendUserMessage(command.text);
+        }
+      }).catch(() => {
+        context?.abort();
+        if (timer) clearInterval(timer);
+      }).finally(() => {
+        polling = false;
+      });
+    }, 100);
+  });
+  pi.on("before_agent_start", async (event, ctx) => {
+    context = ctx;
+    failure = void 0;
+    usage = emptyUsage();
+    reasoningTokens = void 0;
+    costReported = false;
+    await terminalCall("begin", { text: event.prompt });
+  });
+  pi.on("message_end", async (event) => {
+    if (event.message.role !== "assistant") return;
+    if (event.message.stopReason === "error" || event.message.stopReason === "aborted") failure = event.message.errorMessage ?? `Pi stopped: ${event.message.stopReason}`;
+    const text = event.message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+    if (text) await terminalCall("message", { text });
+    if (event.message.usage) {
+      const reported = event.message.usage;
+      usage.inputTokens += reported.input ?? 0;
+      usage.outputTokens += reported.output ?? 0;
+      usage.cacheReadTokens += reported.cacheRead ?? 0;
+      usage.cacheWriteTokens += reported.cacheWrite ?? 0;
+      usage.requests += 1;
+      if (typeof reported.reasoning === "number") reasoningTokens = (reasoningTokens ?? 0) + reported.reasoning;
+      const cost = reported.cost?.total;
+      if (typeof cost === "number") {
+        usage.costUsd += cost;
+        costReported = true;
+      }
+      const identity = { model: event.message.model, provider: event.message.provider };
+      const { costUsd, ...tokens } = usage;
+      await terminalCall("usage", {
+        ...tokens,
+        ...costReported ? { costUsd, costSource: "harness" } : {},
+        ...reasoningTokens === void 0 ? {} : { reasoningTokens },
+        contextTokens: (reported.input ?? 0) + (reported.cacheRead ?? 0) + (reported.cacheWrite ?? 0),
+        ...context?.model?.contextWindow ? { contextWindow: context.model.contextWindow } : {},
+        ...identity,
+        request: {
+          index: usage.requests,
+          ...identity,
+          responseId: event.message.responseId,
+          inputTokens: reported.input ?? 0,
+          cacheReadTokens: reported.cacheRead ?? 0,
+          cacheWriteTokens: reported.cacheWrite ?? 0,
+          outputTokens: reported.output ?? 0,
+          ...typeof reported.reasoning === "number" ? { reasoningTokens: reported.reasoning } : {},
+          ...typeof cost === "number" ? { costUsd: cost, costSource: "harness" } : {},
+          ...requestStartedAt === null ? {} : { durationMs: Date.now() - requestStartedAt },
+          stopReason: event.message.stopReason
+        }
+      });
+      requestStartedAt = null;
+    }
+  });
+  pi.on("turn_start", async () => {
+    requestStartedAt = Date.now();
+  });
+  pi.on("tool_call", async (event) => {
+    try {
+      const policy = await terminalCall("policy", { tool: event.toolName, args: event.input });
+      if (policy.requiresApproval) {
+        const approval = await terminalCall("approval", { requestId: event.toolCallId, target: event.toolName, action: JSON.stringify(event.input), tool: event.toolName, args: event.input });
+        if (approval.decision === "approved") return;
+        return { block: true, reason: "The user denied this action. Ask how they would like to proceed." };
+      }
+      if (!policy.allowed) return { block: true, reason: policy.reason ?? "Outside what this session may do." };
+    } catch {
+      return { block: true, reason: "The terminal controller is unavailable." };
+    }
+  });
+  pi.on("tool_execution_start", async (event) => {
+    if (["edit", "write"].includes(event.toolName) && typeof event.args.path === "string") fileTools.set(event.toolCallId, event.args.path);
+    toolStartedAt.set(event.toolCallId, Date.now());
+    await terminalCall("tool", { phase: "start", id: event.toolCallId, name: event.toolName, summary: JSON.stringify(event.args).slice(0, 200) });
+  });
+  pi.on("tool_execution_end", async (event) => {
+    const started = toolStartedAt.get(event.toolCallId);
+    toolStartedAt.delete(event.toolCallId);
+    const resultChars = resultSize(event.result);
+    await terminalCall("tool", { phase: "end", id: event.toolCallId, name: event.toolName, ok: !event.isError, ...started === void 0 ? {} : { durationMs: Date.now() - started }, ...resultChars === null ? {} : { resultChars } });
+    const path = fileTools.get(event.toolCallId);
+    fileTools.delete(event.toolCallId);
+    if (!event.isError && path) await terminalCall("file", { path, change: "modified" });
+  });
+  pi.on("agent_settled", async () => {
+    await terminalCall("settled", { error: failure });
+  });
+  pi.on("user_bash", async () => {
+    throw new Error("Use the bash tool so this action can be checked.");
+  });
+  pi.on("session_shutdown", async () => {
+    if (timer) clearInterval(timer);
+    await terminalCall("shutdown").catch(() => {
+    });
+  });
+  pi.registerTool({
+    name: "ask_user_question",
+    label: "Ask a question",
+    description: "Ask the user a question and wait for their answer.",
+    parameters: Type.Object({
+      question: Type.String(),
+      options: Type.Optional(Type.Array(Type.Object({ label: Type.String(), description: Type.Optional(Type.String()) }))),
+      multiSelect: Type.Optional(Type.Boolean())
+    }),
+    async execute(id, input) {
+      const answer = await terminalCall("question", { requestId: id, ...input });
+      return { content: [{ type: "text", text: JSON.stringify(answer) }], details: void 0 };
+    }
+  });
+  await terminalCall("startup", { phase: "Pi hooks registered" });
+}
+export {
+  piExtension_default as default
+};

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@xingular/harness",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Xingular Harness \u2014 a Pi agent harness with multi-account sign-in, a compiled system prompt, a memory lifecycle (Wiki), tools, MCP, and skills",
+  "exports": {
+    ".": "./src/index.ts",
+    "./*": "./src/*"
+  },
+  "bin": {
+    "xingular-harness": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "esbuild src/cli.ts --bundle --platform=node --target=node22 --format=esm --packages=external --outfile=dist/cli.js && esbuild src/terminal/piExtension.ts --bundle --platform=node --target=node22 --format=esm --packages=external --outfile=dist/terminal-pi.js",
+    "prepack": "npm run build",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run",
+    "prove": "npm run build && node scripts/prove-standalone.mjs"
+  },
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@modelcontextprotocol/client": "^2.2.0",
+    "@modelcontextprotocol/server": "^2.2.0",
+    "typebox": "^1.3.7",
+    "yaml": "^2.8.1",
+    "zod": "^4.1.11"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.1",
+    "esbuild": "^0.25.10",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "files": [
+    "src",
+    "dist",
+    "builtin",
+    "README.md"
+  ]
+}

package/src/accounts/accounts.test.ts

@@ -0,0 +1,223 @@
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, rmdirSync, statSync, writeFileSync } from 'node:fs'
+import { homedir, tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { expect, test } from 'vitest'
+
+import { Bus, type Notice } from '../core/bus'
+import { Accounts, classifyMessage } from './accounts'
+import { assertIsolated, configDir, ensureHome, ensureSharedDir, launchEnv, nativeConfig, sharedDir } from './env'
+import { fileSecretStore, memorySecretStore } from './secrets'
+import { addAccount, audit, deriveHealth, emptyState, loadRegistry, loadState, resolve, saveRegistry, updateState, type Issue } from './store'
+
+const temp = () => mkdtempSync(join(tmpdir(), 'harness-accounts-'))
+const ago = (ms: number): string => new Date(Date.now() - ms).toISOString()
+const HOUR = 3_600_000
+
+function service(dir = temp()) {
+  const secrets = memorySecretStore()
+  const notices: Notice[] = []
+  const bus = new Bus()
+  bus.on((notice) => void notices.push(notice))
+  return { dir, secrets, notices, accounts: new Accounts({ dir, secrets, bus }) }
+}
+
+test('health reflects sign-in, errors and limits', () => {
+  const state = { ...emptyState(), signedIn: true }
+  expect(deriveHealth(state)).toBe('ok')
+  state.limits.push({ id: '5h', label: '', usedPercent: 100, resetsAt: ago(-HOUR) })
+  expect(deriveHealth(state)).toBe('limited')
+  state.limits[0].resetsAt = ago(HOUR)
+  expect(deriveHealth(state)).toBe('ok')
+  state.lastError = { category: 'auth_expired', message: '', at: '', resetsAt: null }
+  expect(deriveHealth(state)).toBe('auth_expired')
+  state.lastError = null
+  state.signedIn = false
+  expect(deriveHealth(state)).toBe('signed_out')
+})
+
+test('a limit error without a reset time expires', () => {
+  const issue = (at: number, resetsAt: number | null): Issue => ({ category: 'quota', message: 'usage limit', at: ago(at), resetsAt: resetsAt === null ? null : ago(-resetsAt) })
+  const state = { ...emptyState(), signedIn: true }
+  expect(deriveHealth({ ...state, lastError: issue(5 * 60_000, null) })).toBe('limited')
+  expect(deriveHealth({ ...state, lastError: issue(96 * HOUR, null) })).toBe('ok')
+  expect(deriveHealth({ ...state, lastError: issue(96 * HOUR, HOUR) })).toBe('limited')
+})
+
+test('resolve prefers explicit, then pool, then default, and never skips silently', () => {
+  const dir = temp()
+  expect(() => resolve(dir)).toThrow('Add a Pi account first.')
+  const first = addAccount(dir, 'A', 'subscription')
+  const second = addAccount(dir, 'B', 'subscription')
+  expect(resolve(dir).id).toBe(first.id)
+  expect(resolve(dir, second.id).id).toBe(second.id)
+  // An account of a provider the harness no longer runs is kept in the file and never chosen.
+  const registry = loadRegistry(dir)
+  registry.accounts.push({ id: 'legacy', provider: 'codex', label: 'Old', authKind: 'subscription', createdAt: '' })
+  registry.pools.push({ id: 'p', provider: 'pi', label: 'Work', accountIds: [first.id, second.id] })
+  saveRegistry(dir, registry)
+  expect(() => resolve(dir, 'legacy')).toThrow('another provider')
+  expect(loadRegistry(dir).accounts).toHaveLength(3)
+
+  updateState(dir, first.id, (state) => void (state.signedIn = false))
+  expect(resolve(dir, null, 'p').id).toBe(second.id)
+  updateState(dir, second.id, (state) => void (state.lastError = { category: 'auth_expired', message: '', at: '', resetsAt: null }))
+  expect(() => resolve(dir, null, 'p')).toThrow('Every account in Work is unavailable.')
+})
+
+function walk(dir: string): string[] {
+  return readdirSync(dir).flatMap((name) => (statSync(join(dir, name)).isDirectory() ? walk(join(dir, name)) : [join(dir, name)]))
+}
+
+test('audit and state never hold secrets', async () => {
+  const { dir, accounts } = service()
+  audit(dir, 'a', 'login.failed', 'token sk-ant-api03-abcdefghijklmnopqrstuvwxyz0123456789 rejected')
+  const text = readFileSync(join(dir, 'audit.jsonl'), 'utf8')
+  expect(text).not.toContain('abcdefghijklmnop')
+  expect(text).toContain('[redacted]')
+
+  const account = addAccount(dir, 'A', 'apiKey')
+  await accounts.writeCredential(account.id, 'anthropic', { type: 'api_key', key: 'sk-secret-value' })
+  expect((await accounts.readCredential(account.id, 'anthropic'))?.key).toBe('sk-secret-value')
+  for (const file of walk(dir)) expect(readFileSync(file, 'utf8')).not.toContain('sk-secret-value')
+  expect((await accounts.listCredentials(account.id))[0].type).toBe('api_key')
+  await expect(accounts.writeCredential(account.id, '../x', null)).rejects.toThrow('Invalid provider name.')
+})
+
+test('a failed terminal credential launch can retry without a stale reference count', async () => {
+  const { dir, accounts } = service()
+  const account = addAccount(dir, 'A', 'apiKey')
+  ensureHome(dir, account)
+  await accounts.writeCredential(account.id, 'openai', { type: 'api_key', key: 'probe' })
+  const auth = join(configDir(dir, account), 'auth.json')
+  mkdirSync(auth)
+  await expect(accounts.terminalBegin(account)).rejects.toThrow()
+  rmdirSync(auth)
+  await accounts.terminalBegin(account)
+  expect(statSync(auth).isFile()).toBe(true)
+  expect(statSync(auth).mode & 0o777).toBe(0o600)
+  await accounts.terminalEnd(account)
+  expect(existsSync(auth)).toBe(false)
+})
+
+test('a terminal round-trips credentials through auth.json', async () => {
+  const { dir, accounts } = service()
+  const account = addAccount(dir, 'A', 'apiKey')
+  ensureHome(dir, account)
+  await accounts.writeCredential(account.id, 'openai', { type: 'api_key', key: 'k1' })
+  await accounts.terminalBegin(account)
+  const auth = join(configDir(dir, account), 'auth.json')
+  expect(readFileSync(auth, 'utf8')).toContain('k1')
+  writeFileSync(auth, JSON.stringify({ anthropic: { type: 'oauth', access: 'a', refresh: 'r', expires: 1 } }))
+  await accounts.terminalEnd(account)
+  expect(existsSync(auth)).toBe(false)
+  expect(loadState(dir, account.id).piProviders).toEqual(['anthropic'])
+  expect((await accounts.readCredential(account.id, 'anthropic'))?.refresh).toBe('r')
+})
+
+test('creating, renaming and removing an account is audited and announced', async () => {
+  const { dir, accounts, secrets, notices } = service()
+  const created = accounts.create('  Work  ', 'apiKey').accounts[0]
+  expect([created.label, created.isDefault, created.state.health]).toEqual(['Work', true, 'unknown'])
+  expect(lstatSync(join(configDir(dir, created), 'skills')).isSymbolicLink()).toBe(true)
+  await accounts.writeCredential(created.id, 'openai', { type: 'api_key', key: 'k' })
+  expect(() => accounts.create('', 'apiKey')).toThrow()
+  expect(() => accounts.create('x', 'password')).toThrow('Unknown sign-in type.')
+  accounts.rename(created.id, 'Home')
+  await accounts.remove(created.id)
+  expect(accounts.overview().accounts).toEqual([])
+  expect(existsSync(join(dir, created.id))).toBe(false)
+  expect(secrets.values.size).toBe(0)
+  expect(notices.filter((notice) => notice.type === 'accounts.changed').length).toBeGreaterThanOrEqual(3)
+  expect(readFileSync(join(dir, 'audit.jsonl'), 'utf8')).toContain('account.deleted')
+})
+
+test('run events move an account between healthy and limited', () => {
+  const { dir, accounts, notices } = service()
+  const account = addAccount(dir, 'A', 'subscription')
+  const event = (type: string, payload: unknown) => ({ id: 'e', runId: 'r', sessionId: 's', sequence: 0, timestamp: '', type: type as never, payload })
+  accounts.onRunEvent(event('account.status', { accountId: account.id, category: 'quota', message: 'usage limit reached for sk-abcdefghijklmnopqrstuvwxyz012345' }), null)
+  const limited = loadState(dir, account.id)
+  expect(limited.health).toBe('limited')
+  expect(limited.lastError?.message).toContain('[redacted]')
+  expect(notices.at(-1)).toMatchObject({ type: 'accounts.changed', health: 'limited', previous: 'unknown' })
+  // A finished run proves the sign-in works, but a limit error stays until it resets.
+  accounts.onRunEvent(event('completed', {}), { accountId: account.id } as never)
+  expect(loadState(dir, account.id)).toMatchObject({ signedIn: true, health: 'limited' })
+  accounts.onRunEvent(event('account.status', { accountId: account.id, category: 'auth_expired', message: '401' }), null)
+  expect(loadState(dir, account.id)).toMatchObject({ signedIn: false, health: 'auth_expired' })
+  accounts.onRunEvent(event('completed', {}), { accountId: account.id } as never)
+  expect(loadState(dir, account.id).health).toBe('ok')
+})
+
+test('provider errors are classified', () => {
+  expect(classifyMessage('401 Unauthorized')).toBe('auth_expired')
+  expect(classifyMessage('You have hit your usage limit')).toBe('quota')
+  expect(classifyMessage('429 Too Many Requests')).toBe('rate_limited')
+  expect(classifyMessage('fetch failed')).toBe('network')
+  expect(classifyMessage('the model said no')).toBeNull()
+})
+
+test('native config lists what is shared and what exists', () => {
+  const dir = temp()
+  const before = nativeConfig(dir)
+  expect(before.entries.some((entry) => entry.name === 'extensions' && entry.directory)).toBe(true)
+  expect(before.entries.every((entry) => !entry.present)).toBe(true)
+  expect(existsSync(before.path)).toBe(false)
+  writeFileSync(join(ensureSharedDir(dir), 'AGENTS.md'), 'x')
+  expect(nativeConfig(dir).entries.find((entry) => entry.name === 'AGENTS.md')?.present).toBe(true)
+})
+
+test('launch env isolates and strips inherited credentials', () => {
+  const dir = temp()
+  const env = launchEnv(dir, { id: 'acc1' }, { SOMEVENDOR_API_KEY: 'leak', PATH: '/bin' })
+  expect(env.PI_CODING_AGENT_DIR?.startsWith(dir)).toBe(true)
+  expect(env).toMatchObject({ SOMEVENDOR_API_KEY: null, CLAUDE_CONFIG_DIR: null, CODEX_HOME: null })
+  expect('PATH' in env).toBe(false)
+})
+
+test('accounts share config but not credentials', () => {
+  const dir = temp()
+  const first = ensureHome(dir, { id: 'acc1' })
+  const second = ensureHome(dir, { id: 'acc2' })
+  writeFileSync(join(first, 'settings.json'), '{"theme":"dark"}\n')
+  mkdirSync(join(first, 'skills/review'), { recursive: true })
+  writeFileSync(join(first, 'auth.json'), '{}')
+  expect(readFileSync(join(second, 'settings.json'), 'utf8')).toBe('{"theme":"dark"}\n')
+  expect(statSync(join(second, 'skills/review')).isDirectory()).toBe(true)
+  expect(existsSync(join(second, 'auth.json'))).toBe(false)
+  expect(lstatSync(join(first, 'auth.json')).isSymbolicLink()).toBe(false)
+  expect(readlinkSync(join(first, 'skills'))).toBe(join(sharedDir(dir), 'skills'))
+})
+
+test('existing account config moves into the shared folder, newest wins', async () => {
+  const dir = temp()
+  for (const id of ['acc1', 'acc2']) {
+    mkdirSync(configDir(dir, { id }), { recursive: true })
+    writeFileSync(join(configDir(dir, { id }), 'settings.json'), `{"from":"${id}"}`)
+    await new Promise((resolve) => setTimeout(resolve, 20))
+  }
+  ensureHome(dir, { id: 'acc1' })
+  // acc2's settings are newer than the shared copy acc1 just moved in, so they win.
+  const second = ensureHome(dir, { id: 'acc2' })
+  expect(readFileSync(join(sharedDir(dir), 'settings.json'), 'utf8')).toBe('{"from":"acc2"}')
+  expect(readdirSync(sharedDir(dir)).some((name) => name.startsWith('settings.json.agentx-backup-'))).toBe(true)
+  expect(lstatSync(join(second, 'settings.json')).isSymbolicLink()).toBe(true)
+})
+
+test('refuses default tool directories', () => {
+  const dir = temp()
+  for (const name of ['.codex', '.claude', '.pi/agent']) expect(() => assertIsolated(dir, join(homedir(), name))).toThrow()
+  expect(() => assertIsolated(dir, '/tmp/elsewhere')).toThrow()
+  expect(() => assertIsolated(dir, join(dir, 'a/home/pi'))).not.toThrow()
+})
+
+test('a file secret store keeps secrets owner-only', async () => {
+  const path = join(temp(), 'nested/secrets.json')
+  const secrets = fileSecretStore(path)
+  expect(await secrets.get('a/b')).toBeNull()
+  await secrets.set('a/b', 'value')
+  expect(await secrets.get('a/b')).toBe('value')
+  expect(statSync(path).mode & 0o777).toBe(0o600)
+  await secrets.delete('a/b')
+  expect(await secrets.get('a/b')).toBeNull()
+})