@ilya-lesikov/pi-pi 0.1.0

package/extensions/orchestrator/context.test.ts

@@ -0,0 +1,293 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import {
+  getLatestSynthesizedPlan,
+  getPhaseArtifacts,
+  loadContextFiles,
+  loadBrainstormReviewOutputs,
+  loadCodeReviewOutputs,
+  loadPlanReviewOutputs,
+} from "./context.js";
+
+const tempDirs: string[] = [];
+
+function makeTempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "pi-pi-context-test-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("loadContextFiles", () => {
+  it("returns empty array when context directory is missing", () => {
+    const cwd = makeTempDir();
+    expect(loadContextFiles(cwd, "main")).toEqual([]);
+  });
+
+  it("defaults files without frontmatter to context mode and main agent", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+    writeFileSync(join(contextDir, "plain.md"), "hello world\n", "utf-8");
+
+    expect(loadContextFiles(cwd, "main")).toEqual([{ mode: "context", content: "hello world" }]);
+    expect(loadContextFiles(cwd, "explore")).toEqual([]);
+  });
+
+  it("filters by inject mode", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(
+      join(contextDir, "system.md"),
+      "---\ninject: system\nagents: main\n---\nSystem text\n",
+      "utf-8",
+    );
+    writeFileSync(
+      join(contextDir, "context.md"),
+      "---\ninject: context\nagents: main\n---\nContext text\n",
+      "utf-8",
+    );
+
+    expect(loadContextFiles(cwd, "main", "system")).toEqual([{ mode: "system", content: "System text" }]);
+    expect(loadContextFiles(cwd, "main", "context")).toEqual([{ mode: "context", content: "Context text" }]);
+  });
+
+  it("supports specific agents, agent groups, and main default", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(join(contextDir, "all.md"), "---\nagentGroups: all\n---\nall agents\n", "utf-8");
+    writeFileSync(join(contextDir, "sub.md"), "---\nagentGroups: subagents\n---\nsub only\n", "utf-8");
+    writeFileSync(join(contextDir, "explore.md"), "---\nagents: explore\n---\nexplore only\n", "utf-8");
+    writeFileSync(join(contextDir, "default.md"), "---\n\n---\ndefault main\n", "utf-8");
+
+    expect(loadContextFiles(cwd, "main").map((f) => f.content).sort()).toEqual(["all agents", "default main"]);
+    expect(loadContextFiles(cwd, "explore").map((f) => f.content).sort()).toEqual([
+      "all agents",
+      "explore only",
+      "sub only",
+    ]);
+  });
+
+  it("handles quoted frontmatter values and bracket array syntax", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(
+      join(contextDir, "quoted.md"),
+      "---\ninject: \"system\"\nagents: ['main', \"explore\"]\n---\nquoted\n",
+      "utf-8",
+    );
+
+    expect(loadContextFiles(cwd, "main", "system")).toEqual([{ mode: "system", content: "quoted" }]);
+    expect(loadContextFiles(cwd, "explore", "system")).toEqual([{ mode: "system", content: "quoted" }]);
+  });
+
+  it("ignores invalid inject mode and keeps default context mode", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(
+      join(contextDir, "bad-inject.md"),
+      "---\ninject: invalid\nagents: main\n---\nuses default inject\n",
+      "utf-8",
+    );
+
+    expect(loadContextFiles(cwd, "main", "system")).toEqual([]);
+    expect(loadContextFiles(cwd, "main", "context")).toEqual([{ mode: "context", content: "uses default inject" }]);
+  });
+
+  it("filters invalid agent names", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(
+      join(contextDir, "mixed-agents.md"),
+      "---\nagents: [main, unknown, fake]\n---\nonly main allowed\n",
+      "utf-8",
+    );
+
+    expect(loadContextFiles(cwd, "main")).toEqual([{ mode: "context", content: "only main allowed" }]);
+    expect(loadContextFiles(cwd, "explore")).toEqual([]);
+  });
+
+  it("skips non-markdown files", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(join(contextDir, "notes.txt"), "---\nagents: main\n---\nshould skip\n", "utf-8");
+    writeFileSync(join(contextDir, "ok.md"), "---\nagents: main\n---\nshould include\n", "utf-8");
+
+    expect(loadContextFiles(cwd, "main")).toEqual([{ mode: "context", content: "should include" }]);
+  });
+
+  it("logs and skips files that fail to read", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    const brokenPath = join(contextDir, "broken.md");
+    writeFileSync(brokenPath, "broken", "utf-8");
+    chmodSync(brokenPath, 0o000);
+    writeFileSync(join(contextDir, "good.md"), "---\nagents: main\n---\ngood file\n", "utf-8");
+
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+    const result = loadContextFiles(cwd, "main");
+
+    expect(result).toEqual([{ mode: "context", content: "good file" }]);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+    expect(String(errorSpy.mock.calls[0][0])).toContain("Failed to read context file");
+    expect(String(errorSpy.mock.calls[0][0])).toContain("broken.md");
+  });
+});
+
+describe("getPhaseArtifacts", () => {
+  it("returns user request and research artifacts for plan", () => {
+    const taskDir = makeTempDir();
+    writeFileSync(join(taskDir, "USER_REQUEST.md"), "user request", "utf-8");
+    writeFileSync(join(taskDir, "RESEARCH.md"), "research notes", "utf-8");
+
+    expect(getPhaseArtifacts(taskDir, "plan")).toEqual([
+      { name: "USER_REQUEST.md", content: "user request" },
+      { name: "RESEARCH.md", content: "research notes" },
+    ]);
+  });
+
+  it("includes latest synthesized plan for plan and implement", () => {
+    const taskDir = makeTempDir();
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(join(taskDir, "USER_REQUEST.md"), "request", "utf-8");
+    writeFileSync(join(plansDir, "20260101_synthesized.md"), "old plan", "utf-8");
+    writeFileSync(join(plansDir, "20260102_synthesized.md"), "new plan", "utf-8");
+
+    expect(getPhaseArtifacts(taskDir, "implement")).toEqual([
+      { name: "USER_REQUEST.md", content: "request" },
+      { name: "Synthesized Plan", content: "new plan" },
+    ]);
+
+    expect(getPhaseArtifacts(taskDir, "plan")).toEqual([
+      { name: "USER_REQUEST.md", content: "request" },
+      { name: "Synthesized Plan", content: "new plan" },
+    ]);
+  });
+});
+
+describe("getLatestSynthesizedPlan", () => {
+  it("returns null when plans directory is missing or has no synthesized files", () => {
+    const taskDir = makeTempDir();
+    expect(getLatestSynthesizedPlan(taskDir)).toBeNull();
+
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(join(plansDir, "other.md"), "not synthesized", "utf-8");
+
+    expect(getLatestSynthesizedPlan(taskDir)).toBeNull();
+  });
+
+  it("returns content of lexicographically latest synthesized file", () => {
+    const taskDir = makeTempDir();
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+
+    writeFileSync(join(plansDir, "001_synthesized.md"), "first", "utf-8");
+    writeFileSync(join(plansDir, "010_synthesized.md"), "latest", "utf-8");
+
+    expect(getLatestSynthesizedPlan(taskDir)).toBe("latest");
+  });
+});
+
+describe("context regressions", () => {
+  it("parses bracket array values without truncation when closing bracket is missing", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(
+      join(contextDir, "broken-array.md"),
+      "---\nagents: [main, explore\n---\nregression body\n",
+      "utf-8",
+    );
+
+    expect(loadContextFiles(cwd, "main")).toEqual([{ mode: "context", content: "regression body" }]);
+    expect(loadContextFiles(cwd, "explore")).toEqual([{ mode: "context", content: "regression body" }]);
+  });
+
+  it("selects numerically latest synthesized plan in getLatestSynthesizedPlan", () => {
+    const taskDir = makeTempDir();
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+
+    writeFileSync(join(plansDir, "999_synthesized.md"), "old", "utf-8");
+    writeFileSync(join(plansDir, "1000_synthesized.md"), "new", "utf-8");
+
+    expect(getLatestSynthesizedPlan(taskDir)).toBe("new");
+  });
+
+  it("selects numerically latest synthesized plan in getPhaseArtifacts implement phase", () => {
+    const taskDir = makeTempDir();
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+
+    writeFileSync(join(plansDir, "999_synthesized.md"), "old", "utf-8");
+    writeFileSync(join(plansDir, "1000_synthesized.md"), "new", "utf-8");
+
+    expect(getPhaseArtifacts(taskDir, "implement")).toEqual([{ name: "Synthesized Plan", content: "new" }]);
+  });
+
+  it("filters brainstorm and code review outputs by pass", () => {
+    const taskDir = makeTempDir();
+    const brainstormReviewsDir = join(taskDir, "brainstorm-reviews");
+    const codeReviewsDir = join(taskDir, "code-reviews");
+    mkdirSync(brainstormReviewsDir, { recursive: true });
+    mkdirSync(codeReviewsDir, { recursive: true });
+
+    writeFileSync(join(brainstormReviewsDir, "001_alpha_round-1.md"), "brainstorm", "utf-8");
+    writeFileSync(join(brainstormReviewsDir, "003_alpha_round-2.md"), "round2", "utf-8");
+    writeFileSync(join(codeReviewsDir, "002_alpha_round-1.md"), "implement", "utf-8");
+    writeFileSync(join(codeReviewsDir, "004_alpha_round-2.md"), "round2", "utf-8");
+
+    expect(loadBrainstormReviewOutputs(taskDir, 1).map((r) => r.name)).toEqual([
+      "001_alpha_round-1.md",
+    ]);
+    expect(loadCodeReviewOutputs(taskDir, 1).map((r) => r.name)).toEqual([
+      "002_alpha_round-1.md",
+    ]);
+
+    expect(loadBrainstormReviewOutputs(taskDir, 2).map((r) => r.name)).toEqual([
+      "003_alpha_round-2.md",
+    ]);
+    expect(loadCodeReviewOutputs(taskDir, 2).map((r) => r.name)).toEqual([
+      "004_alpha_round-2.md",
+    ]);
+  });
+
+  it("loads all plan review outputs regardless of pass", () => {
+    const taskDir = makeTempDir();
+    const planReviewsDir = join(taskDir, "plan-reviews");
+    mkdirSync(planReviewsDir, { recursive: true });
+
+    writeFileSync(join(planReviewsDir, "001_alpha.md"), "a", "utf-8");
+    writeFileSync(join(planReviewsDir, "002_beta.md"), "b", "utf-8");
+
+    expect(loadPlanReviewOutputs(taskDir).map((r) => r.name)).toEqual([
+      "001_alpha.md",
+      "002_beta.md",
+    ]);
+  });
+});

package/extensions/orchestrator/context.ts

@@ -0,0 +1,206 @@
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+import type { Phase } from "./state.js";
+
+type AgentType = "main" | "explore" | "librarian" | "planner" | "planReviewer" | "task" | "codeReviewer";
+type AgentGroup = "all" | "subagents";
+type InjectMode = "system" | "context";
+
+interface ContextFile {
+  mode: InjectMode;
+  content: string;
+}
+
+interface Frontmatter {
+  inject: InjectMode;
+  agents: AgentType[];
+  agentGroups: AgentGroup[];
+}
+
+const VALID_INJECT_MODES: readonly string[] = ["system", "context"];
+const VALID_AGENTS: readonly string[] = ["main", "explore", "librarian", "planner", "planReviewer", "task", "codeReviewer"];
+const VALID_AGENT_GROUPS: readonly string[] = ["all", "subagents"];
+
+function parseFrontmatter(raw: string): { frontmatter: Frontmatter; body: string } {
+  const match = raw.match(/^---[^\S\n]*\n([\s\S]*?)\n---[^\S\n]*\n([\s\S]*)$/);
+  if (!match) {
+    return {
+      frontmatter: { inject: "context", agents: ["main"], agentGroups: [] },
+      body: raw,
+    };
+  }
+
+  const yamlBlock = match[1];
+  const body = match[2];
+
+  let inject: InjectMode = "context";
+  let agents: AgentType[] = [];
+  let agentGroups: AgentGroup[] = [];
+
+  for (const line of yamlBlock.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+
+    const key = trimmed.slice(0, colonIdx).trim();
+    const val = trimmed.slice(colonIdx + 1).trim();
+
+    if (key === "inject") {
+      const cleaned = stripQuotes(val);
+      if (VALID_INJECT_MODES.includes(cleaned)) {
+        inject = cleaned as InjectMode;
+      }
+    } else if (key === "agents") {
+      agents = parseArray(val).filter((v): v is AgentType => VALID_AGENTS.includes(v));
+    } else if (key === "agentGroups") {
+      agentGroups = parseArray(val).filter((v): v is AgentGroup => VALID_AGENT_GROUPS.includes(v));
+    }
+  }
+
+  if (agents.length === 0 && agentGroups.length === 0) {
+    agents = ["main"];
+  }
+
+  return { frontmatter: { inject, agents, agentGroups }, body };
+}
+
+function stripQuotes(val: string): string {
+  if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+    return val.slice(1, -1);
+  }
+  return val;
+}
+
+function parseArray(val: string): string[] {
+  const trimmed = val.trim();
+  if (trimmed.startsWith("[")) {
+    const closingIdx = trimmed.lastIndexOf("]");
+    const inner = closingIdx > 0 ? trimmed.slice(1, closingIdx) : trimmed.slice(1);
+    return inner
+      .split(",")
+      .map((s) => stripQuotes(s.trim()))
+      .filter(Boolean);
+  }
+  return [stripQuotes(trimmed)];
+}
+
+function sortByTimestampPrefix(a: string, b: string): number {
+  const aNum = parseInt(a, 10);
+  const bNum = parseInt(b, 10);
+  if (!isNaN(aNum) && !isNaN(bNum)) return aNum - bNum;
+  return a.localeCompare(b);
+}
+
+function matchesAgent(fm: Frontmatter, agentType: AgentType): boolean {
+  if (fm.agentGroups.includes("all")) return true;
+  if (fm.agentGroups.includes("subagents") && agentType !== "main") return true;
+  return fm.agents.includes(agentType);
+}
+
+export function loadContextFiles(cwd: string, agentType: AgentType, injectMode?: InjectMode): ContextFile[] {
+  const contextDir = join(cwd, ".pp", "context");
+  if (!existsSync(contextDir)) return [];
+
+  const results: ContextFile[] = [];
+  for (const file of readdirSync(contextDir)) {
+    if (!file.endsWith(".md")) continue;
+    const filePath = join(contextDir, file);
+    let raw: string;
+    try {
+      raw = readFileSync(filePath, "utf-8");
+    } catch (err: any) {
+      console.error(`[pi-pi] Failed to read context file ${filePath}: ${err.message}`);
+      continue;
+    }
+    const { frontmatter, body } = parseFrontmatter(raw);
+
+    if (!matchesAgent(frontmatter, agentType)) continue;
+    if (injectMode && frontmatter.inject !== injectMode) continue;
+
+    results.push({ mode: frontmatter.inject, content: body.trim() });
+  }
+
+  return results;
+}
+
+export function loadAgentsMd(cwd: string): string | null {
+  const agentsPath = join(cwd, "AGENTS.md");
+  if (!existsSync(agentsPath)) return null;
+  return readFileSync(agentsPath, "utf-8");
+}
+
+export function getPhaseArtifacts(taskDir: string, phase: Phase): { name: string; content: string }[] {
+  const artifacts: { name: string; content: string }[] = [];
+
+  const tryAdd = (name: string, path: string) => {
+    if (existsSync(path)) {
+      artifacts.push({ name, content: readFileSync(path, "utf-8") });
+    }
+  };
+
+  tryAdd("USER_REQUEST.md", join(taskDir, "USER_REQUEST.md"));
+  tryAdd("RESEARCH.md", join(taskDir, "RESEARCH.md"));
+
+  const artifactsDir = join(taskDir, "artifacts");
+  if (existsSync(artifactsDir)) {
+    for (const file of readdirSync(artifactsDir).filter((f) => f.endsWith(".md")).sort()) {
+      tryAdd(`artifacts/${file}`, join(artifactsDir, file));
+    }
+  }
+
+  if (phase === "plan" || phase === "implement") {
+    const plansDir = join(taskDir, "plans");
+    if (existsSync(plansDir)) {
+      const synthFiles = readdirSync(plansDir)
+        .filter((f) => f.includes("synthesized"))
+        .sort(sortByTimestampPrefix);
+      if (synthFiles.length > 0) {
+        const synthPath = join(plansDir, synthFiles[synthFiles.length - 1]);
+        tryAdd("Synthesized Plan", synthPath);
+      }
+    }
+  }
+
+  return artifacts;
+}
+
+export function getLatestSynthesizedPlan(taskDir: string): string | null {
+  const plansDir = join(taskDir, "plans");
+  if (!existsSync(plansDir)) return null;
+
+  const synthFiles = readdirSync(plansDir)
+    .filter((f) => f.includes("synthesized"))
+    .sort(sortByTimestampPrefix);
+  if (synthFiles.length === 0) return null;
+
+  return readFileSync(join(plansDir, synthFiles[synthFiles.length - 1]), "utf-8");
+}
+
+export function loadBrainstormReviewOutputs(taskDir: string, pass: number): { name: string; content: string }[] {
+  const dir = join(taskDir, "brainstorm-reviews");
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((f) => f.includes(`round-${pass}`) && f.endsWith(".md"))
+    .sort()
+    .map((name) => ({ name, content: readFileSync(join(dir, name), "utf-8") }));
+}
+
+export function loadCodeReviewOutputs(taskDir: string, pass: number): { name: string; content: string }[] {
+  const dir = join(taskDir, "code-reviews");
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((f) => f.includes(`round-${pass}`) && f.endsWith(".md"))
+    .sort()
+    .map((name) => ({ name, content: readFileSync(join(dir, name), "utf-8") }));
+}
+
+export function loadPlanReviewOutputs(taskDir: string): { name: string; content: string }[] {
+  const dir = join(taskDir, "plan-reviews");
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((f) => f.endsWith(".md"))
+    .sort()
+    .map((name) => ({ name, content: readFileSync(join(dir, name), "utf-8") }));
+}

package/extensions/orchestrator/event-handlers.test.ts

@@ -0,0 +1,190 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { registerEventHandlers } from "./event-handlers.js";
+import { Orchestrator, type ActiveTask } from "./orchestrator.js";
+
+type Handler = (event: any, ctx: any) => any;
+
+function makePi() {
+  const handlers = new Map<string, Handler>();
+  const eventHandlers = new Map<string, Handler>();
+  return {
+    on: vi.fn((name: string, handler: Handler) => {
+      handlers.set(name, handler);
+    }),
+    events: {
+      on: vi.fn((name: string, handler: Handler) => {
+        eventHandlers.set(name, handler);
+      }),
+      emit: vi.fn(),
+    },
+    getAllTools: vi.fn().mockReturnValue([{ name: "lsp" }]),
+    sendMessage: vi.fn(),
+    sendUserMessage: vi.fn(),
+    setModel: vi.fn(),
+    setThinkingLevel: vi.fn(),
+    setSessionName: vi.fn(),
+    _handlers: handlers,
+    _eventHandlers: eventHandlers,
+  };
+}
+
+function makeConfig() {
+  return {
+    mainModel: {
+      implement: { model: "a/b", thinking: "high" },
+      debug: { model: "a/b", thinking: "high" },
+      brainstorm: { model: "a/b", thinking: "high" },
+    },
+    planners: {},
+    planReviewers: {},
+    codeReviewers: {},
+    brainstormReviewers: {},
+    agents: {
+      explore: { model: "x/e", thinking: "low" },
+      librarian: { model: "x/l", thinking: "medium" },
+      task: { model: "x/t", thinking: "medium" },
+    },
+    commands: { afterEdit: [], afterImplement: [] },
+    timeouts: { afterEdit: 1, afterImplement: 1, agentSpawn: 1, agentReadyPing: 1, lockStale: 1, lockUpdate: 1 },
+    autoCommit: false,
+  };
+}
+
+function makeActiveTask(): ActiveTask {
+  return {
+    dir: "/tmp/task",
+    type: "implement",
+    state: {
+      phase: "implement",
+      step: "llm_work",
+      reviewCycle: null,
+      reviewPass: 0,
+      from: null,
+      description: "Test",
+      startedAt: new Date().toISOString(),
+    },
+    release: null,
+    taskId: "123",
+    modifiedFiles: new Set(),
+    reviewPass: 0,
+    description: "Test",
+  };
+}
+
+let pi: ReturnType<typeof makePi>;
+let orchestrator: Orchestrator;
+
+beforeEach(() => {
+  pi = makePi();
+  orchestrator = new Orchestrator(pi as any);
+  orchestrator.cwd = "/project";
+  orchestrator.config = makeConfig() as any;
+  registerEventHandlers(orchestrator);
+});
+
+function getHandler(name: string): Handler {
+  const h = pi._handlers.get(name);
+  if (!h) throw new Error(`No handler for ${name}`);
+  return h;
+}
+
+describe("tool_call write protection", () => {
+  it("blocks non-.md writes to .pp/state/ when input uses path field", async () => {
+    const handler = getHandler("tool_call");
+    const result = await handler(
+      { toolName: "write", input: { path: ".pp/state/implement/123/state.json" } },
+      {},
+    );
+    expect(result).toEqual({ block: true, reason: "Cannot write non-.md files in .pp/state/" });
+  });
+
+  it("blocks state.json writes under .pp/ when input uses path field", async () => {
+    const handler = getHandler("tool_call");
+    const result = await handler(
+      { toolName: "edit", input: { path: ".pp/state.json" } },
+      {},
+    );
+    expect(result).toEqual({ block: true, reason: "state.json is managed by the extension" });
+  });
+
+  it("blocks config.json writes under .pp/ when input uses path field", async () => {
+    const handler = getHandler("tool_call");
+    const result = await handler(
+      { toolName: "write", input: { path: ".pp/config.json" } },
+      {},
+    );
+    expect(result).toEqual({ block: true, reason: "config.json is managed by the user, not the LLM" });
+  });
+
+  it("allows .md writes to .pp/state/ when input uses path field", async () => {
+    const handler = getHandler("tool_call");
+    const result = await handler(
+      { toolName: "write", input: { path: ".pp/state/implement/123/plans/synthesized.md" } },
+      {},
+    );
+    expect(result).toBeUndefined();
+  });
+
+  it("backward compatibility: blocks using file_path field", async () => {
+    const handler = getHandler("tool_call");
+    const result = await handler(
+      { toolName: "write", input: { file_path: ".pp/state/implement/123/state.json" } },
+      {},
+    );
+    expect(result).toEqual({ block: true, reason: "Cannot write non-.md files in .pp/state/" });
+  });
+
+  it("backward compatibility: blocks using filePath field", async () => {
+    const handler = getHandler("tool_call");
+    const result = await handler(
+      { toolName: "edit", input: { filePath: ".pp/config.json" } },
+      {},
+    );
+    expect(result).toEqual({ block: true, reason: "config.json is managed by the user, not the LLM" });
+  });
+});
+
+describe("tool_result implementation tracking", () => {
+  it("adds file to modifiedFiles when input uses path field", async () => {
+    orchestrator.active = makeActiveTask();
+    const handler = getHandler("tool_result");
+    await handler(
+      { toolName: "write", input: { path: "src/index.ts" }, isError: false, content: [] },
+      {},
+    );
+    expect(orchestrator.active.modifiedFiles.has("src/index.ts")).toBe(true);
+  });
+
+  it("skips .pp/ paths in modified-file tracking", async () => {
+    orchestrator.active = makeActiveTask();
+    const handler = getHandler("tool_result");
+    await handler(
+      { toolName: "write", input: { path: ".pp/state/plans/plan.md" }, isError: false, content: [] },
+      {},
+    );
+    expect(orchestrator.active.modifiedFiles.size).toBe(0);
+  });
+
+  it("appends LSP nudge when input uses path field", async () => {
+    orchestrator.active = makeActiveTask();
+    const handler = getHandler("tool_result");
+    const result = await handler(
+      { toolName: "edit", input: { path: "src/foo.ts" }, isError: false, content: [{ type: "text", text: "ok" }] },
+      {},
+    );
+    expect(result?.content).toBeDefined();
+    const lastContent = result.content[result.content.length - 1];
+    expect(lastContent.text).toContain("lsp diagnostics");
+    expect(lastContent.text).toContain("src/foo.ts");
+  });
+
+  it("backward compatibility: tracks file using file_path field", async () => {
+    orchestrator.active = makeActiveTask();
+    const handler = getHandler("tool_result");
+    await handler(
+      { toolName: "edit", input: { file_path: "src/bar.ts" }, isError: false, content: [] },
+      {},
+    );
+    expect(orchestrator.active.modifiedFiles.has("src/bar.ts")).toBe(true);
+  });
+});