mirror of
https://github.com/wassname/pi-goals.git
synced 2026-09-18 12:50:08 +08:00
wassnameandPi/OpenAI
f22d83cd50
Preserve tasks in plan files; update README model illustration and prompt link. 176 tests pass, typecheck and lint clean. Co-Authored-By: Pi/OpenAI <288921227+claudypoo@users.noreply.github.com>
584 lines
33 KiB
TypeScript
584 lines
33 KiB
TypeScript
import { mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
|
|
import { afterEach, expect, it, vi } from "vitest";
|
|
import { scheduleCheckIn } from "../src/prompts.js";
|
|
import prototype from "../src/prototype.js";
|
|
|
|
const roots: string[] = [];
|
|
const shutdowns: Array<() => void> = [];
|
|
afterEach(() => { for (const shutdown of shutdowns.splice(0)) shutdown(); vi.unstubAllEnvs(); for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true }); });
|
|
const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
async function waitFor(predicate: () => boolean, ms = 1500): Promise<void> {
|
|
const start = Date.now();
|
|
while (!predicate()) {
|
|
if (Date.now() - start > ms) throw new Error("timed out waiting for condition");
|
|
await delay(10);
|
|
}
|
|
}
|
|
function fixture(child = false) {
|
|
vi.stubEnv("PI_SUBAGENT_AGENT", child ? "goals-worker" : "");
|
|
const cwd = mkdtempSync(join(tmpdir(), "goals-main-test-")); roots.push(cwd);
|
|
const entries: any[] = []; const hooks = new Map<string, any>(); const commands = new Map<string, any>(); const tools = new Map<string, any>();
|
|
const messages: any[] = [];
|
|
const ctx = { cwd, sessionManager: { getBranch: () => entries, getSessionId: () => "copy-only" }, hasUI: true, ui: {
|
|
theme: { fg: (_color: string, text: string) => text }, notify: vi.fn(), setStatus: vi.fn(), setWidget: vi.fn(), select: vi.fn(async () => "Ready"), editor: vi.fn(),
|
|
} };
|
|
const pi = {
|
|
on: (event: string, hook: any) => hooks.set(event, hook),
|
|
appendEntry: (customType: string, data: any) => entries.push({ type: "custom", customType, data: structuredClone(data) }),
|
|
registerCommand: (name: string, definition: any) => commands.set(name, definition),
|
|
registerTool: (definition: any) => tools.set(definition.name, definition),
|
|
sendMessage: (message: any, options: any) => messages.push({ message, options }),
|
|
sendUserMessage: (content: string, options: any) => messages.push({ message: { content }, options, savedPrompt: true }),
|
|
getAllTools: vi.fn(() => [
|
|
{ name: "subagent", parameters: { properties: { agent: {}, title: {} } } },
|
|
{ name: "subagent_resume", parameters: { properties: { sessionFile: {} } } },
|
|
{ name: "subagent_kill", parameters: { properties: { id: {} } } },
|
|
]),
|
|
};
|
|
prototype(pi as unknown as ExtensionAPI);
|
|
hooks.get("session_start")({}, ctx);
|
|
const command = (value: string) => commands.get("goals").handler(value, ctx);
|
|
const path = join(cwd, ".pi/plan/copy-only-main.md");
|
|
const plan = "# Plan\n- [ ] goal: first output\n- [ ] goal: second output\n\n## Log\n";
|
|
const draft = async () => { await command("new two outputs"); writeFileSync(path, plan); };
|
|
const shutdown = () => hooks.get("session_shutdown")();
|
|
shutdowns.push(shutdown);
|
|
const changed = () => messages.filter((m) => m.message?.content?.includes("Plan changed")).length;
|
|
const atomicWrite = async (text: string) => {
|
|
const tmp = `${path}.tmp`;
|
|
writeFileSync(tmp, text);
|
|
renameSync(tmp, path);
|
|
await delay(25);
|
|
};
|
|
return { ctx, pi, hooks, tools, commands, messages, command, path, plan, draft, shutdown, changed, atomicWrite, entries };
|
|
}
|
|
|
|
it("shows action choices and autocomplete without starting work", async () => {
|
|
const f = fixture();
|
|
f.ctx.ui.select.mockResolvedValueOnce(undefined as any);
|
|
await f.command("");
|
|
expect(f.ctx.ui.select).toHaveBeenCalledWith("Goal plan actions", expect.arrayContaining(["new — New plan", "resume — Continue paused work"]));
|
|
expect(f.messages).toHaveLength(0);
|
|
expect(f.commands.get("goals").getArgumentCompletions("res")).toEqual([{ value: "resume", label: "resume" }]);
|
|
});
|
|
|
|
it.each(["redy", "start", "two outputs", "status extra", "attach some.md solo extra"])("rejects %s without changing the plan or sending a model prompt", async (text) => {
|
|
const f = fixture(); await f.draft();
|
|
const before = readFileSync(f.path, "utf8");
|
|
const entries = f.entries.length; const messages = f.messages.length;
|
|
await f.command(text);
|
|
expect(readFileSync(f.path, "utf8")).toBe(before);
|
|
expect(f.entries).toHaveLength(entries);
|
|
expect(f.messages).toHaveLength(messages);
|
|
});
|
|
|
|
it("requires a model argument without clearing the preference", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("model provider/model");
|
|
const before = readFileSync(f.path, "utf8");
|
|
await f.command("model");
|
|
expect(readFileSync(f.path, "utf8")).toBe(before);
|
|
});
|
|
|
|
it.each(["menu", "command"])("enters planning conversation through %s without an objective box or worker launch", async (route) => {
|
|
const f = fixture();
|
|
f.ctx.ui.select.mockResolvedValueOnce("new — New plan");
|
|
await f.command(route === "menu" ? "" : "new");
|
|
expect(f.entries.at(-1).data.mode).toBe("planning");
|
|
expect(f.ctx.ui.editor).not.toHaveBeenCalled();
|
|
expect(f.messages.at(-1).message.content).toContain("Ask what the user wants to achieve");
|
|
expect(f.hooks.get("tool_call")({ toolName: "subagent" }).block).toBe(true);
|
|
});
|
|
|
|
it("automatically proposes a changed settled draft once and preserves Discuss", async () => {
|
|
const f = fixture(); await f.draft();
|
|
f.ctx.ui.select.mockResolvedValueOnce("Discuss");
|
|
await f.hooks.get("agent_settled")({}, f.ctx);
|
|
expect(f.messages.some(m => m.message.customType === "goal-plan-proposal" && m.message.content === f.plan)).toBe(true);
|
|
expect(f.entries.at(-1).data.mode).toBe("planning");
|
|
const calls = f.ctx.ui.select.mock.calls.length;
|
|
await f.hooks.get("agent_settled")({}, f.ctx);
|
|
expect(f.ctx.ui.select).toHaveBeenCalledTimes(calls);
|
|
writeFileSync(f.path, f.plan.replace("first output", "revised output"));
|
|
f.ctx.ui.select.mockResolvedValueOnce("Ready");
|
|
await f.hooks.get("agent_settled")({}, f.ctx);
|
|
expect(f.entries.at(-1).data.mode).toBe("supervising");
|
|
});
|
|
|
|
it("does not propose an empty draft or a delegated worker's plan", async () => {
|
|
const f = fixture(); await f.command("new");
|
|
await f.hooks.get("agent_settled")({}, f.ctx);
|
|
expect(f.ctx.ui.select).not.toHaveBeenCalled();
|
|
const child = fixture(true); await child.hooks.get("agent_settled")({}, child.ctx);
|
|
expect(child.ctx.ui.select).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("keeps Ready in the same chat, sends saved notices and never installs a context hook", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("review");
|
|
expect(f.entries.at(-1).data.mode).toBe("supervising");
|
|
expect(f.messages.at(-1).options).toEqual({ deliverAs: "followUp" });
|
|
expect(f.messages.at(-1).savedPrompt).toBe(true);
|
|
expect(f.messages.at(-1).message.content).toContain("goals-worker");
|
|
expect(f.hooks.has("context")).toBe(false);
|
|
const event = { systemPrompt: "original system" };
|
|
expect(f.hooks.get("before_agent_start")(event, f.ctx).systemPrompt).toContain("original system");
|
|
f.hooks.get("session_compact")();
|
|
expect(f.hooks.get("before_agent_start")(event, f.ctx).message.content).toContain("Current goal mode: supervising");
|
|
f.shutdown();
|
|
});
|
|
|
|
it("preserves a draft when the wrong subagent package is loaded, and offers explicit solo", async () => {
|
|
const f = fixture(); await f.draft(); f.pi.getAllTools.mockReturnValue([]);
|
|
await f.command("ready"); expect(f.entries.at(-1).data.mode).toBe("planning");
|
|
f.ctx.ui.select.mockResolvedValueOnce("Worker confirmed stopped");
|
|
await f.command("solo"); expect(f.entries.at(-1).data.mode).toBe("solo");
|
|
});
|
|
|
|
it("rejects a plan changed while the human was reviewing it", async () => {
|
|
const f = fixture(); await f.draft();
|
|
f.ctx.ui.select.mockImplementation(async () => { writeFileSync(f.path, "- [ ] goal: substituted\n"); return "Ready"; });
|
|
await f.command("review"); expect(f.entries.at(-1).data.mode).toBe("planning");
|
|
});
|
|
|
|
it("reloads a paused plan without launching, and retains the public worker session handle", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
f.hooks.get("tool_result")({ toolName: "subagent", details: { id: "child-1", sessionFile: "/tmp/child.jsonl" } });
|
|
await f.command("stop");
|
|
expect(f.messages.at(-1).message.content).toContain("Remote stop is NOT yet confirmed");
|
|
f.hooks.get("session_start")({}, f.ctx);
|
|
expect(f.hooks.get("tool_call")({ toolName: "subagent_resume" }).block).toBe(true);
|
|
await f.command("resume");
|
|
expect(f.messages.at(-1).message.content).toContain("/tmp/child.jsonl");
|
|
await f.command("exit"); expect(f.entries.at(-1).data.mode).toBe("chat");
|
|
expect(readFileSync(f.path, "utf8")).toContain("first output");
|
|
});
|
|
|
|
it("requires actual nonempty evidence, distinguishes manual ticks, and retains signoffs on reload", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
const complete = (goal: string, evidence: string[], signal?: AbortSignal) => f.tools.get("CompleteGoal").execute("t", { goal, evidence, observation: "Inspected exact saved bytes" }, signal, undefined, f.ctx);
|
|
expect((await complete("first output", ["missing.log"])).content[0].text).toContain("Evidence unavailable");
|
|
mkdirSync(join(f.ctx.cwd, "evidence")); writeFileSync(join(f.ctx.cwd, "evidence/pass.log"), "actual fixture bytes\n");
|
|
expect((await complete("first output", ["evidence/pass.log"], AbortSignal.abort())).content[0].text).toContain("Cancelled");
|
|
await complete("first output", ["evidence/pass.log"]);
|
|
writeFileSync(f.path, readFileSync(f.path, "utf8").replace("[ ] goal: second", "[x] goal: second"));
|
|
f.hooks.get("session_start")({}, f.ctx);
|
|
expect(f.ctx.ui.setStatus).toHaveBeenLastCalledWith("goals", "goals: supervising | 1/2 reviewed");
|
|
expect(f.ctx.ui.setWidget.mock.lastCall?.[1]).toContain("? = completion claim; parent review still required");
|
|
writeFileSync(f.path, readFileSync(f.path, "utf8").replace("[x] goal: first", "[ ] goal: first"));
|
|
f.hooks.get("agent_end")({}, f.ctx);
|
|
expect(f.ctx.ui.setStatus).toHaveBeenLastCalledWith("goals", "goals: supervising | 0/2 reviewed");
|
|
f.shutdown();
|
|
});
|
|
|
|
it("reviews a plan replaced atomically, and ignores writes that keep the same content", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
await f.atomicWrite(f.plan.replace("## Log", "- discriminator: changed requirement\n## Log"));
|
|
await waitFor(() => f.changed() === 1);
|
|
const review = f.messages.find((m) => m.message.content.includes("Plan changed"))?.message.content;
|
|
expect(review).toContain("Plan changed: ");
|
|
expect(review).toContain(f.path);
|
|
await f.atomicWrite(f.plan.replace("## Log", "- discriminator: same requirement again\n## Log"));
|
|
await waitFor(() => f.changed() === 2);
|
|
// Rewriting identical bytes must not retrigger the review event hook.
|
|
const same = f.plan.replace("## Log", "- discriminator: same requirement again\n## Log");
|
|
writeFileSync(f.path, same); await delay(300);
|
|
expect(f.changed()).toBe(2);
|
|
f.shutdown();
|
|
});
|
|
|
|
it("coalesces duplicate plan-change notifications into one review", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
await f.atomicWrite(f.plan.replace("## Log", "- discriminator: first burst edit\n## Log"));
|
|
await f.atomicWrite(f.plan.replace("## Log", "- discriminator: second burst edit\n## Log"));
|
|
await waitFor(() => f.changed() === 1);
|
|
await delay(200);
|
|
expect(f.changed()).toBe(1);
|
|
f.shutdown();
|
|
});
|
|
|
|
it("stops plan watching on shutdown and re-arms it on reload without duplicating events", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
f.shutdown();
|
|
await f.atomicWrite(f.plan.replace("## Log", "- discriminator: ignored while shut down\n## Log"));
|
|
await delay(150);
|
|
expect(f.changed()).toBe(0);
|
|
f.hooks.get("session_start")({}, f.ctx);
|
|
await f.atomicWrite(f.plan.replace("## Log", "- discriminator: seen after reload\n## Log"));
|
|
await waitFor(() => f.changed() === 1);
|
|
expect(f.changed()).toBe(1);
|
|
f.shutdown();
|
|
});
|
|
|
|
it("does not retrigger a review for its own CompleteGoal plan write", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
mkdirSync(join(f.ctx.cwd, "evidence")); writeFileSync(join(f.ctx.cwd, "evidence/pass.log"), "bytes\n");
|
|
await f.tools.get("CompleteGoal").execute("t", { goal: "first output", evidence: ["evidence/pass.log"], observation: "inspected" }, undefined, undefined, f.ctx);
|
|
await delay(200);
|
|
expect(f.changed()).toBe(0);
|
|
f.shutdown();
|
|
});
|
|
|
|
it("gives pause/exit the session-bound scheduler job removal guidance", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
await f.command("stop");
|
|
const stop = f.messages.at(-1).message.content;
|
|
expect(stop).toContain('goals-copy-only"');
|
|
expect(stop).toContain("Do not add, enable or recreate any job");
|
|
expect(stop).not.toContain("interval '1h'");
|
|
expect(stop).toContain("Remote stop is NOT yet confirmed");
|
|
await f.command("resume");
|
|
await f.command("exit");
|
|
expect(f.messages.at(-1).message.content).toContain('goals-copy-only"');
|
|
expect(f.entries.at(-1).data.mode).toBe("chat");
|
|
});
|
|
|
|
it("tells the model to remove only its own job after the final review", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
mkdirSync(join(f.ctx.cwd, "evidence")); writeFileSync(join(f.ctx.cwd, "evidence/pass.log"), "bytes\n");
|
|
let finalText = "";
|
|
for (const goal of ["first output", "second output"]) {
|
|
finalText = (await f.tools.get("CompleteGoal").execute("t", { goal, evidence: ["evidence/pass.log"], observation: "inspected" }, undefined, undefined, f.ctx)).content[0].text;
|
|
}
|
|
expect(finalText).toContain("All non-cancelled goals are reviewed.");
|
|
expect(finalText).toContain('job named "goals-copy-only"');
|
|
expect(finalText).toContain("leave other jobs untouched");
|
|
f.shutdown();
|
|
});
|
|
|
|
it("retains human-edited and disabled owned schedules without overriding their controls", () => {
|
|
const guidance = scheduleCheckIn("copy-only", ".pi/plan/copy-only-main.md");
|
|
expect(guidance).toContain("List first");
|
|
expect(guidance).toContain("enabled/disabled state unchanged");
|
|
expect(guidance).toContain("never recreate, overwrite or re-enable");
|
|
expect(guidance).toContain("no model override");
|
|
expect(guidance).toContain("Do not reinstall a missing job from a scheduled check-in");
|
|
expect(guidance).toContain("/schedule-prompts");
|
|
});
|
|
|
|
it("restores context after compaction without reinstalling or overriding scheduler jobs", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
f.hooks.get("session_compact")();
|
|
const result = f.hooks.get("before_agent_start")({ systemPrompt: "base" }, f.ctx);
|
|
expect(result.systemPrompt).not.toContain("add one session-bound");
|
|
expect(result.message.content).toContain(f.path);
|
|
});
|
|
|
|
it("recovers from an unreadable plan after compaction instead of restarting work", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
rmSync(f.path);
|
|
f.hooks.get("session_compact")();
|
|
const result = f.hooks.get("before_agent_start")({ systemPrompt: "base" }, f.ctx);
|
|
expect(result.systemPrompt).toContain("ENOENT");
|
|
expect(result.systemPrompt).toContain("do not restart completed work");
|
|
writeFileSync(f.path, f.plan);
|
|
expect(f.hooks.get("before_agent_start")({ systemPrompt: "base" }, f.ctx).message.content).toContain(f.plan.trim());
|
|
f.shutdown();
|
|
});
|
|
|
|
it("requires confirmed worker stop before solo takeover and never lets two writers run together", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
f.hooks.get("tool_result")({ toolName: "subagent", details: { id: "child-1", sessionFile: "/tmp/child.jsonl" } });
|
|
f.ctx.ui.select.mockResolvedValueOnce("Cancel");
|
|
await f.command("solo");
|
|
expect(f.entries.at(-1).data.mode).toBe("supervising"); // cancelled
|
|
f.ctx.ui.select.mockResolvedValueOnce("Worker confirmed stopped");
|
|
await f.command("solo");
|
|
expect(f.entries.at(-1).data.mode).toBe("solo");
|
|
expect(f.hooks.get("tool_call")({ toolName: "subagent" }).block).toBe(true);
|
|
expect(f.hooks.get("tool_call")({ toolName: "subagent_resume" }).block).toBe(true);
|
|
expect(f.hooks.get("tool_call")({ toolName: "subagent_kill" })).toBeUndefined();
|
|
mkdirSync(join(f.ctx.cwd, "evidence")); writeFileSync(join(f.ctx.cwd, "evidence/pass.log"), "bytes\n");
|
|
const text = (await f.tools.get("CompleteGoal").execute("t", { goal: "first output", evidence: ["evidence/pass.log"], observation: "inspected" }, undefined, undefined, f.ctx)).content[0].text;
|
|
expect(text).toContain("self-verification");
|
|
});
|
|
|
|
it("attaches an existing plan without restarting completed work, and restores its noted worker session", async () => {
|
|
const f = fixture();
|
|
const existing = join(f.ctx.cwd, "existing.md");
|
|
writeFileSync(existing, "# Plan\n- preferred worker model: deepseek flash\n- worker session: /tmp/attach-child.jsonl\n- [ ] goal: attached goal\n\n## Log\n- previous progress kept\n");
|
|
f.ctx.ui.select.mockResolvedValueOnce("Previous supervisor confirmed stopped");
|
|
await f.command(`attach ${existing}`);
|
|
expect(f.entries.at(-1).data.mode).toBe("planning");
|
|
expect(f.entries.at(-1).data.plan).toBe(existing);
|
|
expect(f.messages.at(-1).message.content).toContain("without restarting completed work");
|
|
expect(f.messages.at(-1).message.content).toContain("/tmp/attach-child.jsonl");
|
|
});
|
|
|
|
it("attaches directly into solo mode and reports the recorded session in status", async () => {
|
|
const f = fixture();
|
|
const existing = join(f.ctx.cwd, "existing.md");
|
|
writeFileSync(existing, "# Plan\n- worker session: /tmp/attach-child.jsonl\n- [ ] goal: attached goal\n\n## Log\n");
|
|
f.ctx.ui.select.mockResolvedValueOnce("Worker confirmed stopped");
|
|
await f.command(`attach ${existing} solo`);
|
|
expect(f.entries.at(-1).data.mode).toBe("solo");
|
|
expect(f.entries.at(-1).data.worker?.sessionFile).toBe("/tmp/attach-child.jsonl");
|
|
await f.command("status");
|
|
expect(f.ctx.ui.notify).toHaveBeenLastCalledWith(expect.stringContaining("/tmp/attach-child.jsonl"), "info");
|
|
});
|
|
|
|
it("rejects attaching a missing or goal-less file", async () => {
|
|
const f = fixture();
|
|
await f.command("attach /no/such/plan.md");
|
|
expect(f.ctx.ui.notify).toHaveBeenLastCalledWith(expect.stringContaining("Cannot read plan"), "error");
|
|
const goalLess = join(f.ctx.cwd, "notes.md");
|
|
writeFileSync(goalLess, "# notes\n");
|
|
await f.command(`attach ${goalLess}`);
|
|
expect(f.ctx.ui.notify).toHaveBeenLastCalledWith(expect.stringContaining("has no '- [ ] goal:' lines"), "warning");
|
|
expect(f.entries).toEqual([]); // nothing saved: the session was not attached
|
|
});
|
|
|
|
it("exits planning with the draft preserved and nothing implemented", async () => {
|
|
const f = fixture(); await f.draft();
|
|
await f.command("stop");
|
|
expect(f.ctx.ui.notify).toHaveBeenLastCalledWith(expect.stringContaining("A draft cannot pause"), "warning");
|
|
const before = f.messages.length;
|
|
await f.command("exit");
|
|
expect(f.entries.at(-1).data.mode).toBe("chat");
|
|
expect(readFileSync(f.path, "utf8")).toContain("first output");
|
|
expect(f.messages.length).toBe(before); // notify only, no model turn started
|
|
f.ctx.ui.select.mockResolvedValueOnce("Previous supervisor confirmed stopped");
|
|
await f.command(`attach ${f.path}`);
|
|
expect(f.entries.at(-1).data.mode).toBe("planning");
|
|
});
|
|
|
|
it("records the preferred worker model as a visible plan preference", async () => {
|
|
const f = fixture(); await f.draft();
|
|
await f.command("model deepseek flash");
|
|
expect(readFileSync(f.path, "utf8")).toContain("- preferred worker model: deepseek flash");
|
|
await f.command("status");
|
|
expect(f.ctx.ui.notify).toHaveBeenLastCalledWith(expect.stringContaining("deepseek flash"), "info");
|
|
});
|
|
|
|
it.each(["solo", "attach"])("%s takeover cannot bypass confirmation or survive a lifecycle change during the menu", async kind => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
f.hooks.get("tool_result")({ toolName: "subagent", details: { id: "child", sessionFile: "/tmp/prior.jsonl" } });
|
|
let answer!: (choice: string) => void;
|
|
f.ctx.ui.select.mockImplementationOnce(() => new Promise(resolve => { answer = resolve; }));
|
|
const takeover = f.command(kind === "solo" ? "solo" : `attach ${f.path} solo`);
|
|
expect(f.entries.at(-1).data.mode).toBe("supervising");
|
|
await f.command("stop");
|
|
answer("Worker confirmed stopped"); await takeover;
|
|
expect(f.entries.at(-1).data.mode).toBe("paused");
|
|
expect(f.entries.at(-1).data.workerStopped).not.toBe(true);
|
|
});
|
|
|
|
it("attach solo requires stop confirmation for a noted worker even in a fresh session", async () => {
|
|
const f = fixture(); const path = join(f.ctx.cwd, "saved.md");
|
|
writeFileSync(path, `# Plan\n- worker session: /tmp/known.jsonl\n${f.plan}`);
|
|
f.ctx.ui.select.mockResolvedValueOnce("Cancel");
|
|
await f.command(`attach ${path} solo`);
|
|
expect(f.entries).toHaveLength(0);
|
|
f.ctx.ui.select.mockResolvedValueOnce("Worker confirmed stopped");
|
|
await f.command(`attach ${path} solo`);
|
|
expect(f.entries.at(-1).data).toMatchObject({ mode: "solo", workerStopped: true, worker: { sessionFile: "/tmp/known.jsonl" } });
|
|
expect(readFileSync(path, "utf8")).toContain("worker session: /tmp/known.jsonl");
|
|
});
|
|
|
|
it("retains the stopped session reference without permanently blocking another plan", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
f.hooks.get("tool_result")({ toolName: "subagent", details: { id: "child", sessionFile: "/tmp/prior.jsonl" } });
|
|
f.ctx.ui.select.mockResolvedValueOnce("Worker confirmed stopped"); await f.command("solo");
|
|
const other = join(f.ctx.cwd, "another.md"); writeFileSync(other, "- [ ] goal: next\n## Log\n");
|
|
f.ctx.ui.select.mockResolvedValueOnce("Previous supervisor confirmed stopped");
|
|
await f.command(`attach ${other}`);
|
|
expect(f.entries.at(-1).data).toMatchObject({ mode: "planning", plan: other, workerStopped: true, worker: { sessionFile: "/tmp/prior.jsonl" } });
|
|
await f.command("ready");
|
|
f.hooks.get("tool_call")({ toolName: "subagent_resume" });
|
|
expect(f.entries.at(-1).data.workerStopped).toBe(false);
|
|
await f.command("solo");
|
|
expect(f.ctx.ui.notify).toHaveBeenLastCalledWith(expect.stringContaining("still pending"), "warning");
|
|
});
|
|
|
|
it("solo closes a pending plan watcher and sends removal-only scheduler guidance", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
await f.atomicWrite(f.plan.replace("first output", "changed output"));
|
|
f.ctx.ui.select.mockResolvedValueOnce("Worker confirmed stopped"); await f.command("solo");
|
|
expect(f.messages.at(-1).message.content).toContain('job named "goals-copy-only" bound to session "copy-only"');
|
|
expect(f.messages.at(-1).message.content).toContain("Do not add, enable or recreate any job");
|
|
await delay(250);
|
|
await f.atomicWrite(f.plan.replace("first output", "solo output"));
|
|
await delay(250);
|
|
expect(f.changed()).toBe(0);
|
|
});
|
|
|
|
it.each(["missing", "empty", "directory"])("%s plan snapshots never erase signoffs and resync retries after repair", async failure => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
writeFileSync(join(f.ctx.cwd, "proof.log"), "PASS\n");
|
|
await f.tools.get("CompleteGoal").execute("c", { goal: "first output", evidence: ["proof.log"], observation: "Observed PASS" }, undefined, undefined, f.ctx);
|
|
const signed = readFileSync(f.path, "utf8");
|
|
if (failure === "empty") writeFileSync(f.path, "");
|
|
else { rmSync(f.path); if (failure === "directory") mkdirSync(f.path); }
|
|
await delay(250); // also exercise unavailable read after debounce has expired
|
|
f.hooks.get("agent_end")({}, f.ctx);
|
|
expect(f.entries.at(-1).data.signoffs["first output"]).toBeDefined();
|
|
f.hooks.get("session_compact")();
|
|
const unavailable = f.hooks.get("before_agent_start")({ systemPrompt: "base" }, f.ctx);
|
|
expect(unavailable.systemPrompt).toContain("unavailable");
|
|
expect(unavailable.message).toBeUndefined();
|
|
if (failure === "directory") rmSync(f.path, { recursive: true });
|
|
writeFileSync(f.path, signed);
|
|
const resync = f.hooks.get("before_agent_start")({ systemPrompt: "base" }, f.ctx);
|
|
expect(resync.message.content).toContain("Observed PASS");
|
|
await delay(250);
|
|
expect(f.entries.at(-1).data.signoffs["first output"]).toBeDefined();
|
|
expect(f.changed()).toBe(0);
|
|
});
|
|
|
|
it("ignores post-completion maintenance but reviews a real requirement or manual reopening", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
writeFileSync(join(f.ctx.cwd, "proof.log"), "PASS\n");
|
|
for (const goal of ["first output", "second output"]) await f.tools.get("CompleteGoal").execute("c", { goal, evidence: ["proof.log"], observation: "PASS" }, undefined, undefined, f.ctx);
|
|
const signed = readFileSync(f.path, "utf8");
|
|
await f.atomicWrite(signed.replace("## Log", " - evidence: proof.log\n## Log\n- recap: finished"));
|
|
await delay(250);
|
|
expect(f.changed()).toBe(0);
|
|
await f.atomicWrite(signed.replace("## Log", "- discriminator: exact bytes and trailing newline\n## Log"));
|
|
await waitFor(() => f.changed() === 1);
|
|
await f.atomicWrite(signed.replace("[x] goal: first", "[ ] goal: first"));
|
|
await waitFor(() => f.changed() === 2);
|
|
expect(f.entries.at(-1).data.signoffs["first output"]).toBeUndefined();
|
|
});
|
|
|
|
it("cancelled goals do not prevent final cleanup, and solo writes self-verification in Log", async () => {
|
|
const f = fixture(); await f.draft();
|
|
writeFileSync(f.path, f.plan.replace("[ ] goal: second", "[-] goal: second") + "\n## Appendix\nPreserved context\n");
|
|
f.ctx.ui.select.mockResolvedValueOnce("Worker confirmed stopped"); await f.command("solo");
|
|
writeFileSync(join(f.ctx.cwd, "proof.log"), "PASS\n");
|
|
const done = await f.tools.get("CompleteGoal").execute("c", { goal: "first output", evidence: ["proof.log"], observation: "Exact bytes observed" }, undefined, undefined, f.ctx);
|
|
expect(done.content[0].text).toContain("All non-cancelled goals are reviewed");
|
|
const text = readFileSync(f.path, "utf8");
|
|
expect(text).toContain("Solo self-verification:");
|
|
expect(text).not.toContain("Parent review:");
|
|
expect(text.indexOf("Solo self-verification:")).toBeLessThan(text.indexOf("## Appendix"));
|
|
expect(text).toContain("Preserved context");
|
|
});
|
|
|
|
it("lineage-only child attaches its plan with goal-only widget, retains task context, and cannot complete", async () => {
|
|
const f = fixture(true);
|
|
const supplied = join(f.ctx.cwd, "supplied.md");
|
|
const text = "- [/] goal: exact file\n - [ ] verify bytes\n## Log\n - [ ] archived task\n";
|
|
writeFileSync(supplied, text);
|
|
const before = f.hooks.get("before_agent_start")({ systemPrompt: "base" }, f.ctx);
|
|
expect(before.systemPrompt).toContain("AttachGoalPlan");
|
|
const attach = f.tools.get("AttachGoalPlan");
|
|
await attach.execute("a", { path: "supplied.md" }, undefined, undefined, f.ctx);
|
|
expect(f.entries.at(-1).data.plan).toBeUndefined(); // no cwd heuristics
|
|
await attach.execute("a", { path: supplied }, undefined, undefined, f.ctx);
|
|
expect(f.ctx.ui.setWidget.mock.lastCall?.[1]).toEqual(["▸ exact file"]);
|
|
expect(f.ctx.ui.setWidget.mock.lastCall?.[1].join("\n")).not.toContain("archived task");
|
|
expect(readFileSync(supplied, "utf8")).toBe(text);
|
|
f.hooks.get("session_start")({}, f.ctx);
|
|
expect(f.hooks.get("before_agent_start")({ systemPrompt: "base" }, f.ctx).message.content).toContain("exact file");
|
|
const completion = await f.tools.get("CompleteGoal").execute("c", { goal: "exact file", evidence: [], observation: "claim" }, undefined, undefined, f.ctx);
|
|
expect(completion.content[0].text).toContain("only to the active parent");
|
|
});
|
|
|
|
it.each(["solo", "supervising"])("%s widget omits long tasks without altering the plan", async mode => {
|
|
const f = fixture(); await f.draft();
|
|
const text = "- [/] goal: first output\n - [ ] a long task that should never take widget space\n- [ ] goal: second output\n## Log\n";
|
|
writeFileSync(f.path, text);
|
|
if (mode === "solo") { f.ctx.ui.select.mockResolvedValueOnce("Worker confirmed stopped"); await f.command("solo"); }
|
|
else await f.command("ready");
|
|
expect(f.ctx.ui.setWidget.mock.lastCall?.[1]).toEqual(["▸ first output", "○ second output"]);
|
|
expect(readFileSync(f.path, "utf8")).toBe(text);
|
|
});
|
|
|
|
it.each(["solo", "supervising"])("%s upkeep is turn-driven, folds Log, resets on working-set edits, and never starts a turn", async mode => {
|
|
const f = fixture(); await f.draft();
|
|
if (mode === "solo") { f.ctx.ui.select.mockResolvedValueOnce("Worker confirmed stopped"); await f.command("solo"); }
|
|
else await f.command("ready");
|
|
f.hooks.get("before_agent_start")({ systemPrompt: "base" }, f.ctx);
|
|
const reminders = () => f.messages.filter(m => m.message.customType === "pi-goals-upkeep");
|
|
f.hooks.get("turn_end")({}, f.ctx); // observe initial working set
|
|
for (let i = 0; i < 7; i++) {
|
|
writeFileSync(f.path, f.plan + `- historical recap ${i}\n`);
|
|
f.hooks.get("turn_end")({}, f.ctx);
|
|
}
|
|
expect(reminders()).toHaveLength(0);
|
|
f.hooks.get("turn_end")({}, f.ctx);
|
|
expect(reminders()).toHaveLength(1);
|
|
expect(reminders()[0].options).toEqual({ triggerTurn: false });
|
|
expect(reminders()[0].message.content).toContain(f.path);
|
|
expect(reminders()[0].message.content).not.toContain("first output");
|
|
for (let i = 0; i < 16; i++) f.hooks.get("turn_end")({}, f.ctx);
|
|
expect(reminders()).toHaveLength(1);
|
|
expect(reminders()[0].message.content).not.toContain("historical recap");
|
|
for (let i = 0; i < 7; i++) f.hooks.get("turn_end")({}, f.ctx);
|
|
writeFileSync(f.path, f.plan.replace("first output", "refined output"));
|
|
f.hooks.get("turn_end")({}, f.ctx);
|
|
expect(reminders()).toHaveLength(1);
|
|
await f.command("stop");
|
|
for (let i = 0; i < 10; i++) f.hooks.get("turn_end")({}, f.ctx);
|
|
expect(reminders()).toHaveLength(1);
|
|
});
|
|
|
|
it("late worker results invalidate a takeover menu but do not disable plan watching", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
let answer!: (choice: string) => void;
|
|
f.ctx.ui.select.mockImplementationOnce(() => new Promise(resolve => { answer = resolve; }));
|
|
const solo = f.command("solo");
|
|
f.hooks.get("tool_result")({ toolName: "subagent", details: { id: "late-child", sessionFile: "/tmp/late.jsonl" } });
|
|
answer("Worker confirmed stopped"); await solo;
|
|
expect(f.entries.at(-1).data.mode).toBe("supervising");
|
|
expect(f.entries.at(-1).data.workerStopped).toBe(false);
|
|
await f.atomicWrite(f.plan.replace("first output", "new requirement"));
|
|
await waitFor(() => f.changed() === 1);
|
|
});
|
|
|
|
it("changed plan or shutdown during takeover never grants solo permission", async () => {
|
|
const f = fixture(); await f.draft();
|
|
f.ctx.ui.select.mockImplementationOnce(async () => { writeFileSync(f.path, f.plan.replace("first", "changed")); return "Worker confirmed stopped"; });
|
|
await f.command("solo");
|
|
expect(f.entries.at(-1).data.mode).toBe("planning");
|
|
expect(f.ctx.ui.notify).toHaveBeenLastCalledWith(expect.stringContaining("Plan changed during takeover"), "warning");
|
|
f.ctx.ui.select.mockImplementationOnce(async () => { f.shutdown(); return "Worker confirmed stopped"; });
|
|
await f.command("solo");
|
|
expect(f.entries.at(-1).data.mode).toBe("planning");
|
|
});
|
|
|
|
it("requires explicit supervisor ownership confirmation when attaching an existing plan", async () => {
|
|
const f = fixture(); const path = join(f.ctx.cwd, "shared.md");
|
|
writeFileSync(path, f.plan);
|
|
f.ctx.ui.select.mockResolvedValueOnce("Cancel");
|
|
await f.command(`attach ${path}`);
|
|
expect(f.entries).toHaveLength(0);
|
|
f.ctx.ui.select.mockResolvedValueOnce("Previous supervisor confirmed stopped");
|
|
await f.command(`attach ${path}`);
|
|
expect(f.entries.at(-1).data).toMatchObject({ mode: "planning", plan: path });
|
|
});
|
|
|
|
it("does not approve cancelled goals or display current completion for an unavailable plan", async () => {
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
writeFileSync(f.path, "- [-] goal: cancelled output\n## Log\n");
|
|
writeFileSync(join(f.ctx.cwd, "evidence.log"), "verified\n");
|
|
const reply = await f.tools.get("CompleteGoal").execute("t", { goal: "cancelled output", evidence: ["evidence.log"], observation: "read" }, undefined, undefined, f.ctx);
|
|
expect(reply.content[0].text).toContain("no sign-off recorded");
|
|
expect(readFileSync(f.path, "utf8")).toContain("[-]");
|
|
rmSync(f.path);
|
|
f.hooks.get("agent_end")({}, f.ctx);
|
|
expect(f.ctx.ui.setWidget).toHaveBeenLastCalledWith("goals", [expect.stringContaining("unavailable")]);
|
|
});
|
|
|
|
it("uses scheduler storage for ownership and the real public user controls", () => {
|
|
const prompt = scheduleCheckIn("session-1", "/plan.md");
|
|
expect(prompt).toContain(".pi/schedule-prompts.json");
|
|
expect(prompt).toContain("tool text does not expose binding");
|
|
expect(prompt).toContain("Never use cleanup");
|
|
expect(prompt).toContain("deletes disabled jobs");
|
|
expect(prompt).toContain("schedule_prompt update");
|
|
expect(prompt).not.toContain("with /schedule-prompts");
|
|
});
|
|
|
|
it("keeps interactive workers open and supplies the supervisor identity for Intercom reports", async () => {
|
|
const agent = readFileSync(new URL("../prototype/agents/goals-worker.md", import.meta.url), "utf8");
|
|
expect(agent).toContain("auto-exit: false");
|
|
const f = fixture(); await f.draft(); await f.command("ready");
|
|
expect(f.messages.at(-1).message.content).toContain("supervisor Intercom session copy-only");
|
|
const role = f.hooks.get("before_agent_start")({ systemPrompt: "base" }, f.ctx).systemPrompt;
|
|
expect(role).toContain("your Intercom session ID copy-only");
|
|
expect(role).toContain("stop workers before /reload");
|
|
expect(role).not.toContain("Reports arrive automatically");
|
|
});
|