@preapexis/piexis 0.2.4 → 0.2.7

package/tests/agents.test.mjs

@@ -1,605 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, mkdir, readFile, readdir, rm, stat, symlink, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { fileURLToPath } from "node:url";
-import agentsExtension from "../extensions/agents.ts";
-import uiExtension from "../extensions/ui.ts";
-import { matchesKey, visibleWidth } from "@earendil-works/pi-tui";
-import { agentNames, childResourceArgs, initializeAgentConfig, isSmallTask, loadAgentConfig, parseAgentConfig, routeSubagent, subagentTools } from "../lib/agents.ts";
-import { agentConfigSchemaUrl } from "../lib/agent-config.ts";
-import { emptyUsage, limitOutput, piInvocation, runSubagent } from "../lib/subagent-runner.ts";
-
-async function fixture(work) {
-  const root = await mkdtemp(join(tmpdir(), "piexis-agents-"));
-  const cwd = join(root, "project"), agentDir = join(root, "agent");
-  await mkdir(join(cwd, ".pi"), { recursive: true });
-  await mkdir(agentDir);
-  const cli = join(root, "cli.mjs");
-  await writeFile(cli, `
-    let task = "";
-    for await (const chunk of process.stdin) task += chunk;
-    const usage = { input: 10, output: 5, cacheRead: 2, cacheWrite: 1, totalTokens: 18,
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0.01 } };
-    const message = { role: "assistant", content: [{ type: "text", text: JSON.stringify({ task, args: process.argv.slice(2), depth: process.env.PIEXIS_SUBAGENT_DEPTH }) }], usage, stopReason: "stop" };
-    process.stdout.write(JSON.stringify({ type: "message_end", message }) + "\\n");
-  `);
-  try { await work({ root, cwd, agentDir, cli }); }
-  finally { await rm(root, { recursive: true, force: true }); }
-}
-
-async function environment(f, work) {
-  const argv = process.argv, dir = process.env.PI_CODING_AGENT_DIR, depth = process.env.PIEXIS_SUBAGENT_DEPTH;
-  process.argv = [process.execPath, f.cli];
-  process.env.PI_CODING_AGENT_DIR = f.agentDir;
-  delete process.env.PIEXIS_SUBAGENT_DEPTH;
-  try { await work(); }
-  finally {
-    process.argv = argv;
-    for (const [key, value] of [["PI_CODING_AGENT_DIR", dir], ["PIEXIS_SUBAGENT_DEPTH", depth]]) {
-      if (value === undefined) delete process.env[key]; else process.env[key] = value;
-    }
-  }
-}
-
-function harness(f, flag) {
-  const handlers = new Map(), commands = new Map(), shortcuts = new Map(), statuses = new Map(), notifications = [], states = [];
-  let tool, active = ["read", "bash", "edit", "write", "grep", "find", "ls", "AskQuestion", "subagent"], mainModel, effort;
-  const pi = {
-    on(name, handler) { handlers.set(name, handler); }, registerFlag() {}, getFlag: () => flag,
-    registerCommand(name, command) { commands.set(name, command); }, registerTool(value) { tool = value; },
-    registerShortcut(key, shortcut) { shortcuts.set(key, shortcut); },
-    getActiveTools: () => active, setActiveTools(value) { active = value; },
-    getThinkingLevel: () => "high", appendEntry(type, data) { states.push({ type: "custom", customType: type, data }); },
-    async setModel(model) {
-      if (model.id === "unauthenticated") return false;
-      mainModel = model; return true;
-    },
-    setThinkingLevel(value) { effort = value; },
-  };
-  agentsExtension(pi);
-  const ctx = {
-    cwd: f.cwd, hasUI: true, mode: "json", model: { provider: "test", id: "current" }, thinkingLevel: "high",
-    isProjectTrusted: () => true, isIdle: () => true, waitForIdle: async () => {},
-    sessionManager: { getBranch: () => states, getEntries: () => states },
-    modelRegistry: { find: (provider, id) => provider === "test" && id !== "missing" ? { provider, id } : undefined,
-      hasConfiguredAuth: (model) => model.id !== "unauthenticated" },
-    ui: { setStatus(key, value) { statuses.set(key, value); }, notify(...args) { notifications.push(args); }, select: async () => undefined },
-  };
-  return { ctx, handlers, commands, shortcuts, statuses, notifications, states, get tool() { return tool; },
-    get active() { return active; }, get mainModel() { return mainModel; }, get effort() { return effort; },
-    start: () => handlers.get("session_start")({}, ctx),
-    execute: (params, signal, update) => tool.execute("call", params, signal, update, ctx),
-  };
-}
-
-const current = "test/current";
-test("validates configuration and rejects typos, bad models and efforts", () => {
-  assert.deepEqual(parseAgentConfig({}), {});
-  for (const bad of [null, [], { model: "bare-id" }, { model: "test/has space" }, { smallModel: "test/model" },
-    { subagent_variant_overrides: [] }, { subagent_variant_overrides: { worker: {} } },
-    { subagent_variant_overrides: { code: { effort: "huge" } } }, { subagent_variant_overrides: { code: { tools: [] } } }]) {
-    assert.throws(() => parseAgentConfig(bad));
-  }
-  assert.equal(parseAgentConfig({ subagent_model: "provider/org/model", delegate_exploration: true }).delegate_exploration, true);
-  assert.throws(() => parseAgentConfig({ delegate_exploration: "true" }));
-});
-
-test("trusted project config merges fields within overrides without writing settings", async () => {
-  await fixture(async (f) => {
-    const global = { model: "test/main", small_model: "test/small", subagent_variant_overrides: { code: { model: "test/code", effort: "high" }, debug: { effort: "high" } } };
-    const local = { subagent_model: "test/worker", subagent_variant_overrides: { code: { effort: "low" } } };
-    await writeFile(join(f.agentDir, "agents.json"), JSON.stringify(global));
-    await writeFile(join(f.cwd, ".pi", "agents.json"), JSON.stringify(local));
-    const config = await loadAgentConfig(f.cwd, f.agentDir, true);
-    assert.deepEqual(config.subagent_variant_overrides.code, { model: "test/code", effort: "low" });
-    assert.deepEqual(config.subagent_variant_overrides.debug, { effort: "high" });
-    assert.equal(config.small_model, "test/small");
-    assert.equal(config.subagent_model, "test/worker");
-    assert.deepEqual(await loadAgentConfig(f.cwd, f.agentDir, false), global);
-    await writeFile(join(f.cwd, ".pi", "agents.json"), "{bad");
-    await assert.rejects(loadAgentConfig(f.cwd, f.agentDir, true), /agents.json/);
-    assert.deepEqual(await loadAgentConfig(f.cwd, f.agentDir, false), global);
-    await assert.rejects(readFile(join(f.cwd, ".pi", "settings.json")), { code: "ENOENT" });
-  });
-});
-
-test("singular agent.json is preferred per scope, with legacy agents.json fallback", async () => {
-  await fixture(async (f) => {
-    await writeFile(join(f.agentDir, "agents.json"), '{"model":"test/legacy"}');
-    await writeFile(join(f.agentDir, "agent.json"), '{"model":"test/main"}');
-    await writeFile(join(f.cwd, ".pi", "agents.json"), '{"subagent_model":"test/worker"}');
-    assert.equal((await loadAgentConfig(f.cwd, f.agentDir, true)).model, "test/main");
-    assert.equal((await loadAgentConfig(f.cwd, f.agentDir, true)).subagent_model, "test/worker");
-    await writeFile(join(f.cwd, ".pi", "agent.json"), '{"subagent_model":"test/local"}');
-    assert.equal((await loadAgentConfig(f.cwd, f.agentDir, true)).subagent_model, "test/local");
-    assert.equal((await loadAgentConfig(f.cwd, f.agentDir, false)).subagent_model, undefined);
-    await writeFile(join(f.cwd, ".pi", "agent.json"), "{bad");
-    await assert.rejects(loadAgentConfig(f.cwd, f.agentDir, true), /agent.json/);
-  });
-});
-
-test("opt-in agent scaffold uses the active model, restrictive permissions and atomic create-only writes", async () => {
-  await fixture(async (f) => {
-    const created = await Promise.all([initializeAgentConfig(f.cwd, f.agentDir, "test/current"), initializeAgentConfig(f.cwd, f.agentDir, "test/other")]);
-    assert.deepEqual(created, [true, false]);
-    const path = join(f.cwd, ".pi", "agent.json");
-    assert.deepEqual(JSON.parse(await readFile(path, "utf8")), {
-      $schema: agentConfigSchemaUrl, model: "test/current", small_model: "test/current", subagent_model: "test/current", delegate_exploration: false,
-      subagent_variant_overrides: {
-        plan: { model: "test/current", effort: "high" },
-        orchestrator: { model: "test/current", effort: "high" },
-        debug: { model: "test/current", effort: "high" },
-        ask: { model: "test/current", effort: "low" },
-        code: { model: "test/current", effort: "medium" },
-      }
-    });
-    assert.equal((await stat(path)).mode & 0o777, 0o600);
-    assert.deepEqual(await readdir(join(f.cwd, ".pi")), ["agent.json"]);
-    assert.equal((await loadAgentConfig(f.cwd, f.agentDir, true)).model, "test/current");
-  });
-});
-
-test("agent-config command fills only missing project settings", async () => {
-  await fixture(async (f) => environment(f, async () => {
-    await writeFile(join(f.cwd, ".pi", "agent.json"), JSON.stringify({ model: "test/custom", delegate_exploration: true }));
-    const h = harness(f);
-    await h.commands.get("agent-config").handler("", h.ctx);
-    const config = JSON.parse(await readFile(join(f.cwd, ".pi", "agent.json"), "utf8"));
-    assert.equal(config.$schema, agentConfigSchemaUrl);
-    assert.equal(config.model, "test/custom");
-    assert.equal(config.delegate_exploration, true);
-    assert.equal(config.small_model, "test/custom");
-    assert.equal(config.subagent_model, "test/custom");
-    assert.equal(config.subagent_variant_overrides.code.model, "test/custom");
-    assert.match(h.notifications.at(-1)[0], /Added missing/);
-    await h.commands.get("agent-config").handler("", h.ctx);
-    assert.match(h.notifications.at(-1)[0], /already complete/);
-  }));
-});
-
-test("agent scaffold preserves inherited user configuration", async () => {
-  await fixture(async (f) => {
-    const inherited = { model: "test/main", small_model: "test/small", subagent_model: "test/worker", delegate_exploration: true, subagent_variant_overrides: {
-      debug: { effort: "off" }, ask: { model: "test/answer" }, code: { model: "test/code", effort: "max" }
-    } };
-    const path = join(f.agentDir, "agent.json");
-    const original = JSON.stringify(inherited);
-    await writeFile(path, original);
-    assert.equal(await initializeAgentConfig(f.cwd, f.agentDir, "test/current"), true);
-    assert.deepEqual(JSON.parse(await readFile(join(f.cwd, ".pi", "agent.json"), "utf8")), {
-      $schema: agentConfigSchemaUrl,
-      ...inherited,
-      subagent_variant_overrides: {
-        plan: { model: "test/worker", effort: "high" },
-        orchestrator: { model: "test/worker", effort: "high" },
-        debug: { model: "test/worker", effort: "off" },
-        ask: { model: "test/answer", effort: "low" },
-        code: { model: "test/code", effort: "max" },
-      },
-    });
-    assert.equal(await readFile(path, "utf8"), original);
-  });
-});
-
-test("agent scaffold never replaces existing, malformed, legacy or non-regular files", async () => {
-  for (const name of ["agent.json", "agents.json"]) {
-    for (const value of ['{"model":"test/custom"}', "{bad", "directory", "symlink"]) {
-      await fixture(async (f) => {
-        const path = join(f.cwd, ".pi", name);
-        const target = join(f.root, "target.json");
-        if (value === "directory") await mkdir(path);
-        else if (value === "symlink") { await writeFile(target, "do not change"); await symlink(target, path); }
-        else await writeFile(path, value);
-        assert.equal(await initializeAgentConfig(f.cwd, f.agentDir, "test/current"), false);
-        if (value === "symlink") assert.equal(await readFile(target, "utf8"), "do not change");
-        else if (value !== "directory") assert.equal(await readFile(path, "utf8"), value);
-        assert.deepEqual(await readdir(join(f.cwd, ".pi")), [name]);
-      });
-    }
-  }
-});
-
-test("missing models, invalid inherited configuration and cancellation do not create an agent file", async () => {
-  await fixture(async (f) => {
-    await assert.rejects(initializeAgentConfig(f.cwd, f.agentDir, undefined), /No active model/);
-    await assert.rejects(initializeAgentConfig(f.cwd, f.agentDir, "bare-id"), /provider\/model/);
-    const controller = new AbortController(); controller.abort();
-    await assert.rejects(initializeAgentConfig(f.cwd, f.agentDir, "test/current", controller.signal), { name: "AbortError" });
-    await writeFile(join(f.agentDir, "agent.json"), "{bad");
-    await assert.rejects(initializeAgentConfig(f.cwd, f.agentDir, "test/current"), /agent.json/);
-    assert.deepEqual(await readdir(join(f.cwd, ".pi")), []);
-  });
-});
-
-test("automatic small routing is conservative and variant overrides take precedence", () => {
-  const config = { model: "test/main", small_model: "test/small", subagent_model: "test/worker" };
-  for (const task of ["Locate the auth entry point", "What does parseConfig do?", "Summarize README.md"]) {
-    const route = routeSubagent(config, "ask", task, current, "high");
-    assert.deepEqual(route, { model: "test/small", effort: "low", reason: "automatic small task" });
-  }
-  assert.equal(isSmallTask("code", "Fix a typo in README.md"), true);
-  for (const [agent, task] of [["ask", "Explain the security architecture"], ["ask", "Summarize the entire repo"], ["code", "Implement login"], ["debug", "Fix typo"], ["plan", "List files"], ["orchestrator", "Find config"], ["ask", "List " + "x".repeat(401)]]) {
-    assert.equal(routeSubagent(config, agent, task, current, "high").model, "test/worker");
-  }
-  assert.equal(routeSubagent({}, "code", "task", current, "high").model, current);
-  assert.equal(routeSubagent({ model: "test/main" }, "code", "task", current, "high").model, current);
-  const overrides = { ...config, subagent_variant_overrides: { ask: { model: "test/ask", effort: "max" }, code: { effort: "high" } } };
-  assert.deepEqual(routeSubagent(overrides, "ask", "Locate config", current, "off"), { model: "test/ask", effort: "max", reason: "variant override" });
-  assert.equal(routeSubagent(overrides, "code", "Fix a typo", current, "off").effort, "high");
-  assert.deepEqual(routeSubagent(overrides, "ask", "Explore the configuration", current, "high", true), {
-    model: "test/small", effort: "low", reason: "configured exploration small model",
-  });
-  assert.throws(() => routeSubagent({}, "ask", "Explore", current, "high", true), /requires small_model/);
-});
-
-test("child tools never add inactive tools and resource flags preserve explicit extensions", () => {
-  const active = ["read", "bash", "write", "AskQuestion", "subagent", "custom"];
-  assert.deepEqual(subagentTools("ask", active, 1), ["read"]);
-  assert.deepEqual(subagentTools("plan", active, 1), ["read"]);
-  assert.deepEqual(subagentTools("plan", active, 1, true), ["read", "subagent"]);
-  assert.deepEqual(subagentTools("ask", active, 2, true), ["read"]);
-  assert.deepEqual(subagentTools("orchestrator", active, 1), ["read", "bash", "write", "subagent", "custom"]);
-  assert.deepEqual(subagentTools("code", active, 2), ["read", "bash", "write", "custom"]);
-  assert.deepEqual(childResourceArgs(["--model", "test/main", "--no-extensions", "-e", "gate.ts", "--no-mcp", "--api-key", "private", "--", "-e", "bad.ts"]), ["--no-extensions", "-e", "gate.ts", "--no-mcp"]);
-});
-
-test("all five profiles execute as child agents with visible routing and preserved loadout", async () => {
-  await fixture(async (f) => environment(f, async () => {
-    await writeFile(join(f.agentDir, "agents.json"), JSON.stringify({ small_model: "test/small", subagent_model: "test/worker", subagent_variant_overrides: { plan: { model: "test/planner", effort: "max" } } }));
-    process.argv.push("--no-extensions", "-e", "gate.ts");
-    const h = harness(f);
-    await h.start();
-    assert.equal(h.tool.executionMode, "sequential");
-    for (const agent of agentNames) {
-      const updates = [];
-      const result = await h.execute({ agent, task: agent === "ask" ? "Locate the config" : "Complete this task" }, undefined, (value) => updates.push(value));
-      assert.equal(result.isError, false);
-      const output = JSON.parse(result.details.output);
-      assert.equal(output.depth, "1");
-      assert.match(output.task, /^Task:/);
-      assert.ok(output.args.includes("--approve"));
-      assert.ok(output.args.includes("gate.ts"));
-      assert.equal(output.args[output.args.indexOf("--agent") + 1], agent);
-      const tools = output.args[output.args.indexOf("--tools") + 1].split(",");
-      assert.ok(!tools.includes("AskQuestion"));
-      if (["plan", "ask"].includes(agent)) {
-        assert.ok(!tools.includes("bash") && !tools.includes("subagent"));
-        assert.ok(output.args.includes("mcp__*"));
-      }
-      assert.equal(result.details.model, agent === "ask" ? "test/small" : agent === "plan" ? "test/planner" : "test/worker");
-      assert.equal(result.details.effort, agent === "ask" ? "low" : agent === "plan" ? "max" : "high");
-      assert.equal(result.usage.input, 10);
-      assert.match(result.content[0].text, new RegExp(result.details.reason));
-      assert.ok(updates.length > 0);
-    }
-  }));
-});
-
-test("configured exploration always uses the small model and stays read-only", async () => {
-  await fixture(async (f) => environment(f, async () => {
-    await writeFile(join(f.agentDir, "agent.json"), JSON.stringify({
-      small_model: "test/small", delegate_exploration: true,
-      subagent_variant_overrides: { ask: { model: "test/ask", effort: "max" } },
-    }));
-    const h = harness(f);
-    await h.start();
-    assert.match(h.handlers.get("before_agent_start")({ systemPrompt: "base" }).systemPrompt, /purpose: explore/);
-    const result = await h.execute({ agent: "ask", purpose: "explore", task: "Locate configuration loading" });
-    assert.equal(result.details.model, "test/small");
-    assert.equal(result.details.effort, "low");
-    assert.equal(result.details.reason, "configured exploration small model");
-    assert.deepEqual(h.ctx.model, { provider: "test", id: "current" });
-    const output = JSON.parse(result.details.output);
-    const tools = output.args[output.args.indexOf("--tools") + 1].split(",");
-    assert.ok(!tools.includes("subagent") && !tools.includes("bash"));
-    await assert.rejects(h.execute({ agent: "plan", purpose: "explore", task: "Locate configuration loading" }), /requires agent: ask/);
-    await writeFile(join(f.agentDir, "agent.json"), JSON.stringify({ small_model: "test/small", delegate_exploration: false }));
-    await assert.rejects(h.execute({ agent: "ask", purpose: "explore", task: "Locate configuration loading" }), /Enable delegate_exploration/);
-    await writeFile(join(f.agentDir, "agent.json"), JSON.stringify({ delegate_exploration: true }));
-    await assert.rejects(h.execute({ agent: "ask", purpose: "explore", task: "Locate configuration loading" }), /requires small_model/);
-  }));
-});
-
-test("profile commands cancel cleanly, inject instructions, persist and restore branch state", async () => {
-  await fixture(async (f) => environment(f, async () => {
-    const h = harness(f);
-    await h.start();
-    const command = h.commands.get("agent");
-    const prompt = () => h.handlers.get("before_agent_start")({ systemPrompt: "base" }, h.ctx).systemPrompt;
-    await command.handler("", h.ctx);
-    assert.equal(h.states.length, 0);
-    await command.handler("plan", h.ctx);
-    assert.match(prompt(), /base[\s\S]*profile: plan/);
-    await assert.rejects(h.execute({ agent: "code", task: "Make changes" }), /only to plan or ask/);
-    await command.handler("nonsense", h.ctx);
-    assert.match(prompt(), /profile: plan/);
-    await command.handler("debug", h.ctx);
-    assert.match(prompt(), /trace its cause/);
-    h.states.pop();
-    h.handlers.get("session_tree")({}, h.ctx);
-    assert.match(prompt(), /profile: plan/);
-    h.states.length = 0;
-    h.handlers.get("session_tree")({}, h.ctx);
-    assert.match(prompt(), /profile: code/);
-  }));
-});
-
-test("Alt+A cycles all profiles, persists the selection and respects busy/non-TUI sessions", async () => {
-  await fixture(async (f) => environment(f, async () => {
-    const h = harness(f);
-    h.ctx.mode = "tui";
-    await h.start();
-    assert.equal(h.shortcuts.size, 1);
-    const shortcut = h.shortcuts.get("alt+a");
-    assert.ok(shortcut);
-    assert.ok(matchesKey("\u001ba", "alt+a"));
-    assert.equal(h.statuses.get("piexis-agent"), "agent:code");
-    for (const name of agentNames) {
-      await shortcut.handler(h.ctx);
-      assert.equal(h.statuses.get("piexis-agent"), `agent:${name}`);
-      assert.equal(h.states.at(-1).data.agent, name);
-      assert.match(h.handlers.get("before_agent_start")({ systemPrompt: "base" }).systemPrompt, new RegExp(`profile: ${name}`));
-    }
-    const count = h.states.length;
-    h.ctx.isIdle = () => false;
-    await shortcut.handler(h.ctx);
-    assert.equal(h.states.length, count);
-    assert.equal(h.notifications.at(-1)[1], "warning");
-    h.ctx.isIdle = () => true;
-    for (const mode of ["json", "rpc", "print"]) {
-      h.ctx.mode = mode;
-      await shortcut.handler(h.ctx);
-      assert.equal(h.states.length, count);
-    }
-    h.ctx.mode = "tui";
-    await h.commands.get("agent").handler("debug", h.ctx);
-    await shortcut.handler(h.ctx);
-    assert.equal(h.statuses.get("piexis-agent"), "agent:ask");
-    h.states.pop();
-    h.handlers.get("session_tree")({}, h.ctx);
-    assert.equal(h.statuses.get("piexis-agent"), "agent:debug");
-    const resumed = harness(f);
-    resumed.states.push(...h.states);
-    await resumed.start();
-    assert.equal(resumed.statuses.get("piexis-agent"), "agent:debug");
-  }));
-});
-
-test("commands, picker and cycling apply merged profile models and effort", async () => {
-  await fixture(async (f) => environment(f, async () => {
-    await writeFile(join(f.agentDir, "agent.json"), JSON.stringify({
-      model: "test/main", small_model: "test/small", subagent_model: "test/worker",
-      subagent_variant_overrides: { plan: { model: "test/planner", effort: "high" }, debug: { effort: "max" } },
-    }));
-    await writeFile(join(f.cwd, ".pi", "agent.json"), JSON.stringify({
-      subagent_variant_overrides: { plan: { effort: "low" }, ask: { model: "test/answer", effort: "off" } },
-    }));
-    const h = harness(f);
-    h.ctx.mode = "tui";
-    await h.start();
-    await h.shortcuts.get("alt+a").handler(h.ctx);
-    assert.equal(h.mainModel.id, "planner");
-    assert.equal(h.effort, "low");
-    assert.equal(h.statuses.get("piexis-agent"), "agent:plan");
-    await h.commands.get("agent").handler("debug", h.ctx);
-    assert.equal(h.mainModel.id, "main");
-    assert.equal(h.effort, "max");
-    h.ctx.ui.select = async () => "ask";
-    await h.commands.get("agent").handler("", h.ctx);
-    assert.equal(h.mainModel.id, "answer");
-    assert.equal(h.effort, "off");
-    h.ctx.isProjectTrusted = () => false;
-    await h.commands.get("agent").handler("plan", h.ctx);
-    assert.equal(h.mainModel.id, "planner");
-    assert.equal(h.effort, "high");
-  }));
-});
-
-test("unconfigured profile fields leave current settings alone", async () => {
-  await fixture(async (f) => environment(f, async () => {
-    const h = harness(f);
-    await h.commands.get("agent").handler("plan", h.ctx);
-    assert.equal(h.mainModel, undefined);
-    assert.equal(h.effort, undefined);
-    await writeFile(join(f.agentDir, "agent.json"), JSON.stringify({
-      small_model: "test/small", subagent_model: "test/worker",
-      subagent_variant_overrides: { ask: { effort: "low" }, code: { model: "test/coder" } },
-    }));
-    await h.commands.get("agent").handler("ask", h.ctx);
-    assert.equal(h.mainModel, undefined);
-    assert.equal(h.effort, "low");
-    await h.commands.get("agent").handler("code", h.ctx);
-    assert.equal(h.mainModel.id, "coder");
-    assert.equal(h.effort, "low");
-  }));
-});
-
-test("failed profile switches preserve model, effort and profile and release the switch guard", async () => {
-  await fixture(async (f) => environment(f, async () => {
-    const h = harness(f);
-    h.ctx.mode = "tui";
-    await h.start();
-    await writeFile(join(f.agentDir, "agent.json"), JSON.stringify({
-      subagent_variant_overrides: { code: { model: "test/coder", effort: "medium" } },
-    }));
-    await h.commands.get("agent").handler("code", h.ctx);
-    const count = h.states.length;
-    for (const value of ["{bad", ...["missing", "unauthenticated"].map((id) => JSON.stringify({
-      subagent_variant_overrides: { plan: { model: `test/${id}`, effort: "max" } },
-    }))]) {
-      await writeFile(join(f.agentDir, "agent.json"), value);
-      await h.shortcuts.get("alt+a").handler(h.ctx);
-      assert.equal(h.mainModel.id, "coder");
-      assert.equal(h.effort, "medium");
-      assert.equal(h.statuses.get("piexis-agent"), "agent:code");
-      assert.equal(h.states.length, count);
-      assert.equal(h.notifications.at(-1)[1], "warning");
-    }
-    await writeFile(join(f.agentDir, "agent.json"), "{}");
-    await Promise.all([h.shortcuts.get("alt+a").handler(h.ctx), h.commands.get("agent").handler("ask", h.ctx)]);
-    assert.equal(h.states.length, count + 1);
-    assert.equal(h.statuses.get("piexis-agent"), "agent:plan");
-    await h.commands.get("agent").handler("ask", h.ctx);
-    assert.equal(h.statuses.get("piexis-agent"), "agent:ask");
-  }));
-});
-
-test("footer reads live agent status after commands, cycling and tree restoration without losing width bounds", async () => {
-  await fixture(async (f) => environment(f, async () => {
-    const h = harness(f);
-    h.ctx.mode = "tui";
-    h.ctx.getContextUsage = () => undefined;
-    const uiHandlers = new Map();
-    const theme = { fg: (_color, text) => `\u001b[36m${text}\u001b[39m`, bold: (text) => `\u001b[1m${text}\u001b[22m` };
-    let footer;
-    Object.assign(h.ctx.ui, {
-      setTitle() {}, setHeader() {},
-      setFooter(make) { footer = make({ requestRender() {} }, theme, {
-        getGitBranch: () => "main", getExtensionStatuses: () => h.statuses, onBranchChange: () => () => {},
-      }); },
-    });
-    uiExtension({ on(name, handler) { uiHandlers.set(name, handler); }, getThinkingLevel: () => "high" });
-    await uiHandlers.get("session_start")({}, h.ctx);
-    try {
-      assert.doesNotMatch(footer.render(160).join("\n"), /agent:/);
-      await h.start();
-      assert.match(footer.render(160).join("\n"), /agent:code/);
-      assert.match(footer.render(160).join("\n"), /Alt\+A/);
-      for (const name of agentNames) {
-        await h.shortcuts.get("alt+a").handler(h.ctx);
-        for (const width of [40, 60, 80, 160]) {
-          const rows = footer.render(width);
-          assert.match(rows.join("\n"), new RegExp(`agent:${name}`));
-          for (const row of rows) assert.ok(visibleWidth(row) <= width);
-        }
-      }
-      await h.commands.get("agent").handler("debug", h.ctx);
-      assert.match(footer.render(160).join("\n"), /agent:debug/);
-      h.states.pop();
-      h.handlers.get("session_tree")({}, h.ctx);
-      assert.match(footer.render(160).join("\n"), /agent:code/);
-      h.ctx.model = { id: "研究🚀".repeat(100) };
-      for (let width = 0; width <= 160; width++) {
-        for (const row of footer.render(width)) assert.ok(visibleWidth(row) <= width);
-      }
-      assert.match(footer.render(40).join("\n"), /agent:code/);
-      h.statuses.clear();
-      assert.doesNotMatch(footer.render(160).join("\n"), /agent:|Alt\+A/);
-    } finally { footer.dispose(); }
-  }));
-});
-
-test("configured main model initializes only new sessions, not CLI overrides or resumes", async () => {
-  await fixture(async (f) => environment(f, async () => {
-    await writeFile(join(f.agentDir, "agents.json"), '{"model":"test/main"}');
-    const h = harness(f, "ask");
-    await h.start();
-    assert.equal(h.mainModel.id, "main");
-    assert.match(h.handlers.get("before_agent_start")({ systemPrompt: "base" }).systemPrompt, /profile: ask/);
-    process.argv.push("--model", "test/explicit");
-    const explicit = harness(f);
-    await explicit.start();
-    assert.equal(explicit.mainModel, undefined);
-    process.argv.length -= 2;
-    const resumed = harness(f);
-    resumed.states.push({ type: "message" });
-    await resumed.start();
-    assert.equal(resumed.mainModel, undefined);
-  }));
-});
-
-test("invalid requests, unavailable models and depth limits fail without spawning", async () => {
-  await fixture(async (f) => environment(f, async () => {
-    const h = harness(f);
-    for (const params of [{ agent: "worker", task: "task" }, { agent: "code", task: " " }]) await assert.rejects(h.execute(params));
-    for (const id of ["missing", "unauthenticated"]) {
-      await writeFile(join(f.agentDir, "agents.json"), JSON.stringify({ subagent_model: `test/${id}` }));
-      await assert.rejects(h.execute({ agent: "code", task: "task" }), /unavailable/);
-    }
-    process.env.PIEXIS_SUBAGENT_DEPTH = "2";
-    const nested = harness(f);
-    await nested.start();
-    assert.ok(!nested.active.includes("subagent"));
-    await assert.rejects(nested.execute({ agent: "orchestrator", task: "task" }), /depth limit/);
-  }));
-});
-
-test("runner handles UTF-8 framing, multiple text blocks, tool usage, retries and failed responses", async () => {
-  await fixture(async (f) => {
-    const usage = emptyUsage(); usage.input = 4; usage.totalTokens = 4;
-    const events = [
-      { type: "message_end", message: { role: "assistant", content: [], stopReason: "error", errorMessage: "temporary", usage } },
-      { type: "message_end", message: { role: "toolResult", usage } },
-      { type: "message_end", message: { role: "assistant", content: [{ type: "text", text: "你好\u2028🌍" }, { type: "text", text: "done" }], stopReason: "stop", usage } },
-    ];
-    await writeFile(f.cli, `const data = Buffer.from(${JSON.stringify(events.map((event) => JSON.stringify(event)).join("\n"))}); for (const byte of data) process.stdout.write(Buffer.from([byte]));`);
-    const run = () => runSubagent({ invocation: { command: process.execPath, args: [f.cli] }, args: [], cwd: f.cwd, depth: 1, task: "task", signal: new AbortController().signal });
-    const result = await run();
-    assert.equal(result.output, "你好\u2028🌍\ndone");
-    assert.equal(result.error, undefined);
-    assert.equal(result.usage.input, 12);
-    await writeFile(f.cli, `console.log(${JSON.stringify(JSON.stringify({ type: "message_end", message: { role: "assistant", content: [], stopReason: "error", errorMessage: "provider failed" } }))});`);
-    const failed = await run();
-    assert.equal(failed.exitCode, 0);
-    assert.equal(failed.error, "provider failed");
-    await writeFile(f.cli, 'process.stderr.write("startup failed"); process.exitCode = 3;');
-    assert.equal((await run()).exitCode, 3);
-    await writeFile(f.cli, 'console.log("not json");');
-    await assert.rejects(run(), /Invalid JSON/);
-    assert.match(limitOutput("x".repeat(60_000)), /truncated/);
-  });
-});
-
-test("real Pi CLI delegates to automatic and explicit small models without network or credentials", { timeout: 30_000 }, async () => {
-  await fixture(async (f) => {
-    for (const mode of ["lookup", "orchestrator", "exploration"]) {
-      const orchestrate = mode === "orchestrator";
-      const exploration = mode === "exploration";
-      await writeFile(join(f.agentDir, "agents.json"), JSON.stringify({ small_model: "piexis-test/small", delegate_exploration: true }));
-      const invocation = piInvocation();
-      const args = [...invocation.args, "--offline", "--no-session", "--mode", "json", "--no-extensions", "--no-skills", "--no-context-files", "--no-prompt-templates",
-        "-e", fileURLToPath(new URL("../extensions/agents.ts", import.meta.url)),
-        "-e", fileURLToPath(new URL("./fixtures/agents-provider.ts", import.meta.url)),
-        "--model", "piexis-test/main", "--tools", "subagent,read", "--", orchestrate ? "Use orchestrator for a lookup" : exploration ? "Delegate exploration" : "Delegate a lookup"];
-      const executionPromise = promisify(execFile)(invocation.command, args, {
-        cwd: f.cwd, env: { ...process.env, PI_CODING_AGENT_DIR: f.agentDir, PIEXIS_SUBAGENT_DEPTH: "0", PI_OFFLINE: "1" },
-        timeout: 25_000, maxBuffer: 4 * 1024 * 1024,
-      });
-      executionPromise.child.stdin.end();
-      const { stdout } = await executionPromise;
-      const events = stdout.trim().split("\n").map((line) => JSON.parse(line));
-      const execution = events.find((event) => event.type === "tool_execution_end" && event.toolName === "subagent");
-      assert.ok(execution, stdout);
-      assert.equal(execution.isError, false, JSON.stringify(execution));
-      assert.equal(execution.result.details.model, orchestrate ? "piexis-test/main" : "piexis-test/small");
-      assert.equal(execution.result.details.reason, orchestrate ? "default subagent" : exploration ? "configured exploration small model" : "automatic small task");
-      if (orchestrate) assert.match(execution.result.details.output, /child:small;depth:2/);
-      else assert.equal(execution.result.details.output, "child:small;depth:1");
-      assert.equal(execution.result.usage.input, orchestrate ? 30 : 10);
-      assert.ok(events.some((event) => event.type === "message_end" && event.message.content?.some((part) => part.text === "parent completed")));
-    }
-  });
-});
-
-test("abort and shutdown terminate running children; pre-aborted calls never start", { timeout: 10_000 }, async () => {
-  await fixture(async (f) => environment(f, async () => {
-    await writeFile(f.cli, 'process.on("SIGTERM", () => {}); console.log(JSON.stringify({type:"tool_execution_start",toolName:"read"})); setInterval(() => {}, 1000);');
-    const h = harness(f);
-    const pre = new AbortController(); pre.abort();
-    await assert.rejects(h.execute({ agent: "code", task: "task" }, pre.signal), { name: "AbortError" });
-    for (const shutdown of [false, true]) {
-      const controller = new AbortController();
-      let ready;
-      const started = new Promise((resolve) => { ready = resolve; });
-      const pending = h.execute({ agent: "code", task: "task" }, controller.signal, ready);
-      const rejected = assert.rejects(pending, /aborted/);
-      await started;
-      if (shutdown) await h.handlers.get("session_shutdown")(); else controller.abort();
-      await rejected;
-    }
-  }));
-});

package/tests/ask-question-pty.test.mjs

@@ -1,16 +0,0 @@
-import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import test from "node:test";
-
-const python = spawnSync("python3", ["-c", "import pty, termios"], { encoding: "utf8" });
-const driver = fileURLToPath(new URL("fixtures/ask-question-pty.py", import.meta.url));
-const fixture = fileURLToPath(new URL("fixtures/ask-question-terminal.mjs", import.meta.url));
-
-for (const scenario of ["single", "multi", "text", "other", "navigation", "cancel", "ctrl-c", "abort"]) {
-  test(`real terminal: ${scenario}, focus restoration and cleanup`, { skip: python.status !== 0 ? "Python/Unix PTY support unavailable" : false }, () => {
-    const result = spawnSync("python3", [driver, fixture, scenario, process.execPath], { encoding: "utf8", timeout: 12000 });
-    assert.equal(result.status, 0, result.stderr + result.stdout);
-    assert.equal(JSON.parse(result.stdout).terminalRestored, true);
-  });
-}