@ilya-lesikov/pi-pi 0.5.0 → 0.6.0

package/extensions/orchestrator/repo-utils.test.ts

@@ -0,0 +1,151 @@
+import { mkdtempSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  findRootRepo,
+  getBaseBranchForRepo,
+  groupFilesByRepo,
+  isPathInRepo,
+  normalizeRepoPath,
+  resolveRepoForFile,
+  type RepoInfo,
+} from "./repo-utils.js";
+
+const tempDirs: string[] = [];
+
+function makeTempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "pi-pi-repo-utils-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("isPathInRepo", () => {
+  it("rejects boundary prefix paths", () => {
+    const base = makeTempDir();
+    const repoPath = join(base, "repo");
+    const siblingPath = join(base, "repo-sibling", "src", "file.ts");
+    mkdirSync(join(repoPath, "src"), { recursive: true });
+    mkdirSync(join(base, "repo-sibling", "src"), { recursive: true });
+    writeFileSync(join(repoPath, "src", "index.ts"), "export {};\n", "utf-8");
+    writeFileSync(siblingPath, "export {};\n", "utf-8");
+
+    expect(isPathInRepo(siblingPath, repoPath)).toBe(false);
+  });
+});
+
+describe("resolveRepoForFile", () => {
+  it("resolves files under symlinked path to canonical repo", () => {
+    const base = makeTempDir();
+    const realRepo = join(base, "real-repo");
+    const linkRepo = join(base, "linked-repo");
+    mkdirSync(join(realRepo, "src"), { recursive: true });
+    writeFileSync(join(realRepo, "src", "app.ts"), "export const app = true;\n", "utf-8");
+    symlinkSync(realRepo, linkRepo, "dir");
+
+    const repos: RepoInfo[] = [{ path: normalizeRepoPath(realRepo), isRoot: false }];
+    const fileViaLink = join(linkRepo, "src", "app.ts");
+
+    expect(resolveRepoForFile(repos, fileViaLink)?.path).toBe(normalizeRepoPath(realRepo));
+  });
+
+  it("picks longest matching repo path", () => {
+    const base = makeTempDir();
+    const parentRepo = join(base, "repo");
+    const nestedRepo = join(parentRepo, "nested");
+    const nestedFile = join(nestedRepo, "src", "main.ts");
+    mkdirSync(join(parentRepo, "src"), { recursive: true });
+    mkdirSync(join(nestedRepo, "src"), { recursive: true });
+    writeFileSync(join(parentRepo, "src", "root.ts"), "export const root = true;\n", "utf-8");
+    writeFileSync(nestedFile, "export const nested = true;\n", "utf-8");
+
+    const repos: RepoInfo[] = [
+      { path: normalizeRepoPath(parentRepo), isRoot: true },
+      { path: normalizeRepoPath(nestedRepo), isRoot: false },
+    ];
+
+    expect(resolveRepoForFile(repos, nestedFile)?.path).toBe(normalizeRepoPath(nestedRepo));
+  });
+});
+
+describe("groupFilesByRepo", () => {
+  it("groups files by matching repository paths", () => {
+    const base = makeTempDir();
+    const rootRepo = join(base, "root");
+    const extraRepo = join(base, "extra");
+    mkdirSync(join(rootRepo, "src"), { recursive: true });
+    mkdirSync(join(extraRepo, "lib"), { recursive: true });
+    const rootFile = join(rootRepo, "src", "a.ts");
+    const extraFile = join(extraRepo, "lib", "b.ts");
+    writeFileSync(rootFile, "export const a = 1;\n", "utf-8");
+    writeFileSync(extraFile, "export const b = 2;\n", "utf-8");
+
+    const repos: RepoInfo[] = [
+      { path: normalizeRepoPath(rootRepo), isRoot: true },
+      { path: normalizeRepoPath(extraRepo), isRoot: false },
+    ];
+
+    const grouped = groupFilesByRepo(repos, [rootFile, extraFile]);
+
+    expect(grouped.get(normalizeRepoPath(rootRepo))).toEqual([rootFile]);
+    expect(grouped.get(normalizeRepoPath(extraRepo))).toEqual([extraFile]);
+  });
+
+  it("puts unmatched files under empty-key bucket", () => {
+    const base = makeTempDir();
+    const repo = join(base, "repo");
+    const outside = join(base, "outside.ts");
+    mkdirSync(join(repo, "src"), { recursive: true });
+    writeFileSync(join(repo, "src", "a.ts"), "export const a = 1;\n", "utf-8");
+    writeFileSync(outside, "export const outside = 1;\n", "utf-8");
+
+    const repos: RepoInfo[] = [{ path: normalizeRepoPath(repo), isRoot: true }];
+
+    const grouped = groupFilesByRepo(repos, [outside]);
+
+    expect(grouped.get("")).toEqual([outside]);
+  });
+});
+
+describe("findRootRepo", () => {
+  it("finds root repository entry", () => {
+    const repos: RepoInfo[] = [
+      { path: "/tmp/a", isRoot: false },
+      { path: "/tmp/b", isRoot: true },
+    ];
+
+    expect(findRootRepo(repos)).toEqual({ path: "/tmp/b", isRoot: true });
+  });
+
+  it("returns undefined when no root repo exists", () => {
+    const repos: RepoInfo[] = [{ path: "/tmp/a", isRoot: false }];
+
+    expect(findRootRepo(repos)).toBeUndefined();
+  });
+});
+
+describe("getBaseBranchForRepo", () => {
+  it("returns base branch for matching repository path", () => {
+    const base = makeTempDir();
+    const repoPath = join(base, "repo");
+    mkdirSync(repoPath, { recursive: true });
+    const repos: RepoInfo[] = [{ path: normalizeRepoPath(repoPath), isRoot: true, baseBranch: "origin/main" }];
+
+    expect(getBaseBranchForRepo(repos, repoPath)).toBe("origin/main");
+  });
+
+  it("returns undefined for unknown repository path", () => {
+    const base = makeTempDir();
+    const repoPath = join(base, "repo");
+    mkdirSync(repoPath, { recursive: true });
+    const repos: RepoInfo[] = [{ path: normalizeRepoPath(repoPath), isRoot: true, baseBranch: "origin/main" }];
+
+    expect(getBaseBranchForRepo(repos, join(base, "missing"))).toBeUndefined();
+  });
+});

package/extensions/orchestrator/repo-utils.ts

@@ -0,0 +1,67 @@
+import { realpathSync, existsSync } from "fs";
+import { resolve, sep } from "path";
+
+export interface RepoInfo {
+  path: string;
+  baseBranch?: string;
+  isRoot: boolean;
+}
+
+export function normalizeRepoPath(p: string): string {
+  const abs = resolve(p);
+  try {
+    return existsSync(abs) ? realpathSync(abs) : abs;
+  } catch {
+    return abs;
+  }
+}
+
+export function isPathInRepo(filePath: string, repoPath: string): boolean {
+  let normFile = resolve(filePath);
+  try {
+    if (existsSync(normFile)) {
+      normFile = realpathSync(normFile);
+    }
+  } catch {}
+  const normalizedRepoPath = normalizeRepoPath(repoPath);
+  const normRepo = normalizedRepoPath.endsWith(sep) ? normalizedRepoPath : normalizedRepoPath + sep;
+  return normFile === normalizedRepoPath || normFile.startsWith(normRepo);
+}
+
+export function resolveRepoForFile(repos: RepoInfo[], filePath: string): RepoInfo | null {
+  const normFile = resolve(filePath);
+  let best: RepoInfo | null = null;
+  let bestLen = 0;
+  for (const repo of repos) {
+    if (isPathInRepo(normFile, repo.path) && repo.path.length > bestLen) {
+      best = repo;
+      bestLen = repo.path.length;
+    }
+  }
+  return best;
+}
+
+export function groupFilesByRepo(repos: RepoInfo[], files: string[]): Map<string, string[]> {
+  const groups = new Map<string, string[]>();
+  for (const file of files) {
+    const repo = resolveRepoForFile(repos, file);
+    const key = repo?.path ?? "";
+    const list = groups.get(key);
+    if (list) list.push(file);
+    else groups.set(key, [file]);
+  }
+  return groups;
+}
+
+export function getBaseBranchForRepo(repos: RepoInfo[], repoPath: string): string | undefined {
+  const norm = normalizeRepoPath(repoPath);
+  return repos.find((r) => r.path === norm)?.baseBranch;
+}
+
+export function getAllRepos(repos: RepoInfo[]): RepoInfo[] {
+  return repos;
+}
+
+export function findRootRepo(repos: RepoInfo[]): RepoInfo | undefined {
+  return repos.find((r) => r.isRoot);
+}

package/extensions/orchestrator/spawn-cleanup.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, vi } from "vitest";
+import { handleSpawnResult } from "./spawn-cleanup.js";
+import type { Orchestrator } from "./orchestrator.js";
+
+function makeOrchestrator(): Orchestrator {
+  return {
+    pendingSubagentSpawns: 3,
+    failedPlannerVariants: [],
+    failedReviewerVariants: [],
+  } as unknown as Orchestrator;
+}
+
+describe("handleSpawnResult", () => {
+  it("resets pending and records failed planner variants on success", async () => {
+    const orch = makeOrchestrator();
+    const onSettled = vi.fn();
+    handleSpawnResult(orch, Promise.resolve({ spawned: 2, agentIds: ["a"], failedVariants: ["bad"] }), {
+      kind: "planner",
+      logScope: "planner",
+      logMessage: "x",
+      onSettled,
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(orch.pendingSubagentSpawns).toBe(0);
+    expect(orch.failedPlannerVariants).toEqual(["bad"]);
+    expect(onSettled).toHaveBeenCalledOnce();
+  });
+
+  it("resets pending and still runs onSettled on rejection (fail-safe)", async () => {
+    const orch = makeOrchestrator();
+    const onSettled = vi.fn();
+    handleSpawnResult(orch, Promise.reject(new Error("boom")), {
+      kind: "reviewer",
+      logScope: "review",
+      logMessage: "x",
+      onSettled,
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(orch.pendingSubagentSpawns).toBe(0);
+    expect(onSettled).toHaveBeenCalledOnce();
+  });
+
+  it("targets failedReviewerVariants for the reviewer kind", async () => {
+    const orch = makeOrchestrator();
+    handleSpawnResult(orch, Promise.resolve({ spawned: 0, agentIds: [], failedVariants: ["r"] }), {
+      kind: "reviewer",
+      logScope: "review",
+      logMessage: "x",
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(orch.failedReviewerVariants).toEqual(["r"]);
+    expect(orch.pendingSubagentSpawns).toBe(0);
+  });
+});

package/extensions/orchestrator/spawn-cleanup.ts

@@ -0,0 +1,35 @@
+import type { Orchestrator } from "./orchestrator.js";
+import { getLogger } from "./log.js";
+
+type SpawnResult = { spawned: number; agentIds?: string[]; failedVariants: string[] };
+
+type SpawnCleanupOptions = {
+  kind: "planner" | "reviewer";
+  logScope: string;
+  logMessage: string;
+  logExtra?: Record<string, unknown>;
+  onSettled?: (result?: SpawnResult) => void;
+};
+
+// Centralizes the cleanup that runs after a planner/reviewer spawn promise
+// settles. The spawn functions block until every spawned agent completes, so
+// resetting pendingSubagentSpawns to 0 is the fail-safe for the spawned===0
+// case and the .catch path where no subagents:completed event fires.
+export function handleSpawnResult(
+  orchestrator: Orchestrator,
+  promise: Promise<SpawnResult>,
+  opts: SpawnCleanupOptions,
+): void {
+  const field = opts.kind === "planner" ? "failedPlannerVariants" : "failedReviewerVariants";
+  promise
+    .then((result) => {
+      orchestrator[field] = result.failedVariants;
+      orchestrator.pendingSubagentSpawns = 0;
+      opts.onSettled?.(result);
+    })
+    .catch((err: any) => {
+      orchestrator.pendingSubagentSpawns = 0;
+      opts.onSettled?.();
+      getLogger().error({ s: opts.logScope, ...opts.logExtra, err: err.message }, opts.logMessage);
+    });
+}

package/extensions/orchestrator/state.test.ts

@@ -1,9 +1,21 @@
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
-import { join } from "path";
+import { join, resolve } from "path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import lockfile from "proper-lockfile";
-import { createTask, getActiveTask, listTasks, loadTask, saveTask, taskAge, taskName, validateFromPath, type TaskState } from "./state.js";
+import {
+  createTask,
+  getActiveTask,
+  getEffectiveMode,
+  getFirstPhase,
+  listTasks,
+  loadTask,
+  saveTask,
+  taskAge,
+  taskName,
+  validateFromPath,
+  type TaskState,
+} from "./state.js";
 
 const tempDirs: string[] = [];
 
@@ -30,6 +42,7 @@ describe("createTask", () => {
     expect(taskDir).toContain(join(cwd, ".pp", "state", "implement"));
     expect(state.phase).toBe("brainstorm");
     expect(state.from).toBeNull();
+    expect(state.repos).toEqual([{ path: resolve(cwd), isRoot: true }]);
     expect(state.description).toBe("Build New Feature");
     expect(new Date(state.startedAt).toString()).not.toBe("Invalid Date");
 
@@ -56,6 +69,21 @@ describe("createTask", () => {
     expect(state.reviewCycle).toBeNull();
     expect(state.reviewPass).toBe(0);
   });
+
+  it("uses quick as initial phase for quick tasks", () => {
+    const cwd = makeCwd();
+    const taskDir = createTask(cwd, "quick", "Quick fix");
+    const state = loadTask(taskDir);
+    expect(state.phase).toBe("quick");
+    expect(state.step).toBe("llm_work");
+  });
+
+  it("stores task mode when provided", () => {
+    const cwd = makeCwd();
+    const taskDir = createTask(cwd, "implement", "Build New Feature", "autonomous");
+    const state = loadTask(taskDir);
+    expect(state.mode).toBe("autonomous");
+  });
 });
 
 describe("loadTask", () => {
@@ -81,12 +109,16 @@ describe("saveTask", () => {
     const taskDir = createTask(cwd, "implement", "Initial");
     const state: TaskState = {
       phase: "implement",
+      initialPhase: "implement",
       step: "user_gate",
       reviewCycle: { kind: "auto", step: "await_reviewers", pass: 2 },
       reviewPass: 1,
+      repos: [],
       from: "implement/some-task",
       description: "Updated",
       startedAt: "2026-04-20T00:00:00.000Z",
+      plannerFailureAutoRetried: false,
+      reviewerFailureAutoRetried: false,
     };
 
     saveTask(taskDir, state);
@@ -125,12 +157,10 @@ describe("listTasks", () => {
     const corrupt = createTask(cwd, "implement", "Broken task");
     writeFileSync(join(corrupt, "state.json"), "{ nope", "utf-8");
 
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
     const tasks = listTasks(cwd, "implement");
 
     expect(tasks).toHaveLength(1);
     expect(tasks[0].state.description).toBe("Healthy task");
-    expect(errorSpy).toHaveBeenCalled();
   });
 });
 
@@ -202,9 +232,7 @@ describe("taskName", () => {
     const taskDir = join(cwd, ".pp", "state", "implement", "123456789012_my-fallback-name");
     mkdirSync(taskDir, { recursive: true });
 
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
     expect(taskName(taskDir)).toBe("my fallback name");
-    expect(errorSpy).toHaveBeenCalled();
   });
 });
 
@@ -341,3 +369,45 @@ describe("getActiveTask", () => {
     expect(checkSpy).toHaveBeenCalledWith(join(taskDir, "state.json"), expect.objectContaining({ stale: 1234 }));
   });
 });
+
+describe("getFirstPhase", () => {
+  it("returns expected first phase for each task type", () => {
+    expect(getFirstPhase("implement")).toBe("brainstorm");
+    expect(getFirstPhase("brainstorm")).toBe("brainstorm");
+    expect(getFirstPhase("debug")).toBe("debug");
+    expect(getFirstPhase("review")).toBe("review");
+    expect(getFirstPhase("quick")).toBe("quick");
+  });
+});
+
+describe("getEffectiveMode", () => {
+  function baseState(): TaskState {
+    return {
+      phase: "brainstorm",
+      step: "llm_work",
+      reviewCycle: null,
+      reviewPass: 0,
+      from: null,
+      description: "x",
+      startedAt: new Date().toISOString(),
+    };
+  }
+
+  it("returns effectiveMode when it is set", () => {
+    const state: TaskState = { ...baseState(), mode: "guided", effectiveMode: "autonomous" };
+
+    expect(getEffectiveMode(state)).toBe("autonomous");
+  });
+
+  it("falls back to mode when effectiveMode is undefined", () => {
+    const state: TaskState = { ...baseState(), mode: "guided" };
+
+    expect(getEffectiveMode(state)).toBe("guided");
+  });
+
+  it("returns undefined when both effectiveMode and mode are undefined", () => {
+    const state: TaskState = { ...baseState() };
+
+    expect(getEffectiveMode(state)).toBeUndefined();
+  });
+});

package/extensions/orchestrator/state.ts

@@ -1,38 +1,63 @@
-import { appendFileSync, readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
-import { join, basename, resolve } from "path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
+import { join, basename, resolve, relative, isAbsolute, sep } from "path";
 import lockfile from "proper-lockfile";
+import { normalizeRepoPath, type RepoInfo } from "./repo-utils.js";
+import { getLogger } from "./log.js";
 
 function getLockfileFs(): typeof import("fs") | undefined {
   try {
     const fs = require("fs");
     fs.statSync(process.cwd());
     return fs;
-  } catch {
+  } catch (err: any) {
+    getLogger().debug({ s: "state", err: err?.message }, "getLockfileFs unavailable");
     return undefined;
   }
 }
 import type { TimeoutConfig } from "./config.js";
 
-export type TaskType = "implement" | "debug" | "brainstorm" | "review";
+export type TaskMode = "guided" | "autonomous";
+
+export interface AutonomousPhaseConfig {
+  plannerPreset?: string;
+  reviewPreset?: string;
+  maxReviewPasses: number;
+}
+
+export interface AutonomousConfig {
+  phases: Record<string, AutonomousPhaseConfig>;
+}
+
+export type TaskType = "implement" | "debug" | "brainstorm" | "review" | "quick";
 
 export type ImplementPhase = "brainstorm" | "plan" | "implement" | "done";
 export type DebugPhase = "debug" | "plan" | "implement" | "done";
 export type BrainstormPhase = "brainstorm" | "plan" | "implement" | "done";
 export type ReviewPhase = "review" | "plan" | "implement" | "done";
-export type Phase = ImplementPhase | DebugPhase | BrainstormPhase | ReviewPhase;
+export type QuickPhase = "quick";
+export type Phase = ImplementPhase | DebugPhase | BrainstormPhase | ReviewPhase | QuickPhase;
 
 export interface TaskState {
   phase: Phase;
+  initialPhase?: string;
   step: string | null;
   reviewCycle: { kind: string; step: string; pass: number } | null;
   reviewPass: number;
-  reviewPassByKind?: Record<string, number>;
+  reviewPassByKind?: Record<string, Record<string, number>>;
+  reviewApprovedClean?: boolean;
   modifiedFiles?: string[];
-  repoCwd?: string;
+  committedFiles?: string[];
+  repos?: RepoInfo[];
   from: string | null;
   description: string;
   startedAt: string;
-
+  activePlannerPreset?: string;
+  activeReviewPreset?: string;
+  mode?: TaskMode;
+  effectiveMode?: TaskMode;
+  autonomousConfig?: AutonomousConfig;
+  plannerFailureAutoRetried?: boolean;
+  reviewerFailureAutoRetried?: boolean;
 }
 
 export interface TaskInfo {
@@ -49,7 +74,27 @@ function taskStatePath(taskDir: string): string {
   return join(taskDir, "state.json");
 }
 
-export function createTask(cwd: string, type: TaskType, description: string): string {
+export function getFirstPhase(type: TaskType): Exclude<Phase, "done"> {
+  if (type === "implement" || type === "brainstorm") return "brainstorm";
+  if (type === "debug") return "debug";
+  if (type === "review") return "review";
+  return "quick";
+}
+
+export function getEffectiveMode(state: TaskState): TaskMode | undefined {
+  return state.effectiveMode ?? state.mode;
+}
+
+// The research first phases (brainstorm/debug/review) are always interactive: the user
+// drives them, so they never inherit the task's autonomous mode even when one is set.
+// plan/implement are autonomous-capable regardless of whether they are the task's initial phase.
+export function getEffectivePhaseMode(state: TaskState): TaskMode {
+  if (state.phase === "brainstorm" || state.phase === "debug" || state.phase === "review") return "guided";
+  return getEffectiveMode(state) ?? "guided";
+}
+
+export function createTask(cwd: string, type: TaskType, description: string, mode?: TaskMode): string {
+  const log = getLogger();
   const id = crypto.randomUUID().slice(0, 12);
   const safeName = description
     .toLowerCase()
@@ -62,16 +107,22 @@ export function createTask(cwd: string, type: TaskType, description: string): st
   mkdirSync(taskDir, { recursive: true });
 
   const state: TaskState = {
-    phase: type === "implement" ? "brainstorm" : type === "debug" ? "debug" : type === "review" ? "review" : "brainstorm",
+    phase: getFirstPhase(type),
+    initialPhase: getFirstPhase(type),
     step: "llm_work",
     reviewCycle: null,
     reviewPass: 0,
+    repos: [{ path: normalizeRepoPath(cwd), isRoot: true }],
     from: null,
     description,
     startedAt: new Date().toISOString(),
+    mode,
+    plannerFailureAutoRetried: false,
+    reviewerFailureAutoRetried: false,
   };
 
   writeFileSync(taskStatePath(taskDir), JSON.stringify(state, null, 2) + "\n", "utf-8");
+  log.info({ s: "task", taskDir, type, description, phase: state.phase }, "task created");
   return taskDir;
 }
 
@@ -80,6 +131,23 @@ export function loadTask(taskDir: string): TaskState {
   const raw = readFileSync(sp, "utf-8");
   try {
     const state = JSON.parse(raw) as TaskState;
+    if ((state as any).phase === "planning") {
+      state.phase = "plan";
+    }
+    if (!state.initialPhase) {
+      state.initialPhase = state.phase;
+    }
+    if (state.plannerFailureAutoRetried === undefined) {
+      state.plannerFailureAutoRetried = false;
+    }
+    if (state.reviewerFailureAutoRetried === undefined) {
+      state.reviewerFailureAutoRetried = false;
+    }
+    if ((state as any).repoCwd && (!state.repos || state.repos.length === 0)) {
+      state.repos = [{ path: (state as any).repoCwd, isRoot: false }];
+    }
+    if (!state.repos) state.repos = [];
+    delete (state as any).repoCwd;
     return state;
   } catch (err: any) {
     throw new Error(`Failed to parse ${sp}: ${err.message}`);
@@ -87,6 +155,7 @@ export function loadTask(taskDir: string): TaskState {
 }
 
 export function saveTask(taskDir: string, state: TaskState): void {
+  getLogger().debug({ s: "task", taskDir, phase: state.phase, step: state.step }, "saving task state");
   writeFileSync(taskStatePath(taskDir), JSON.stringify(state, null, 2) + "\n", "utf-8");
 }
 
@@ -94,7 +163,7 @@ export function listTasks(cwd: string, type?: TaskType): TaskInfo[] {
   const base = stateDir(cwd);
   if (!existsSync(base)) return [];
 
-  const types: TaskType[] = type ? [type] : ["implement", "debug", "brainstorm", "review"];
+  const types: TaskType[] = type ? [type] : ["implement", "debug", "brainstorm", "review", "quick"];
   const results: TaskInfo[] = [];
 
   for (const t of types) {
@@ -113,7 +182,7 @@ export function listTasks(cwd: string, type?: TaskType): TaskInfo[] {
           results.push({ dir, state, type: t });
         }
       } catch {
-        console.error(`[pi-pi] Skipping corrupt task at ${dir}`);
+        getLogger().warn({ s: "state", dir }, "skipping corrupt task");
       }
     }
   }
@@ -135,11 +204,11 @@ export async function lockTask(taskDir: string, timeouts: TimeoutConfig): Promis
   const lockFs = getLockfileFs();
   const release = await lockfile.lock(sp, {
     ...(lockFs && { fs: lockFs }),
-    stale: timeouts.lockStale,
-    update: timeouts.lockUpdate,
+    stale: timeouts.taskLockStale,
+    update: timeouts.taskLockRefresh,
     retries: { retries: 3, minTimeout: 200, maxTimeout: 1000 },
     onCompromised: (err: Error) => {
-      console.error(`[pi-pi] Lock compromised for ${sp}: ${err.message}`);
+      getLogger().error({ s: "state", path: sp, err: err.message }, "lock compromised");
     },
   });
   return release;
@@ -158,7 +227,7 @@ export function getActiveTask(cwd: string, lockStale?: number): TaskInfo | null
         unlocked.push(task);
       }
     } catch {
-      console.error(`[pi-pi] Failed to check lock for ${task.dir}`);
+      getLogger().warn({ s: "state", dir: task.dir }, "failed to check lock");
     }
   }
 
@@ -173,8 +242,9 @@ export function validateFromPath(cwd: string, fromPath: string): { ok: true; dir
 
   const stateRoot = resolve(stateDir(cwd));
   const resolved = resolve(stateRoot, fromPath);
+  const rel = relative(stateRoot, resolved);
 
-  if (resolved !== stateRoot && !resolved.startsWith(stateRoot + "/")) {
+  if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
     return { ok: false, reason: "Path escapes .pp/state/ directory" };
   }
 
@@ -195,7 +265,7 @@ export function taskName(taskDir: string): string {
     const state = loadTask(taskDir);
     let desc = state.description ?? "";
 
-    if (["implement", "debug", "brainstorm", "review"].includes(desc)) {
+    if (["implement", "debug", "brainstorm", "review", "quick"].includes(desc)) {
       const urPath = join(taskDir, "USER_REQUEST.md");
       if (existsSync(urPath)) {
         const content = readFileSync(urPath, "utf-8");
@@ -211,7 +281,7 @@ export function taskName(taskDir: string): string {
       return desc;
     }
   } catch {
-    console.error(`[pi-pi] Failed to read task name from ${taskDir}`);
+    getLogger().warn({ s: "state", taskDir }, "failed to read task name");
   }
   const dir = basename(taskDir);
   const match = dir.match(/^\d+_(.+)$/);
@@ -227,10 +297,3 @@ export function taskAge(state: TaskState): string {
   if (hours < 24) return `${hours}h`;
   return `${Math.floor(hours / 24)}d`;
 }
-
-export function appendTaskLog(taskDir: string, fileName: string, entry: Record<string, unknown>): string {
-  mkdirSync(taskDir, { recursive: true });
-  const filePath = join(taskDir, fileName);
-  appendFileSync(filePath, JSON.stringify(entry) + "\n", "utf-8");
-  return filePath;
-}