pi-orchestrator-config 4.2.1 → 4.3.2

package/extensions/orchestrator/subagent-tool.ts

@@ -16,6 +16,7 @@ import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { Message } from "@earendil-works/pi-ai";
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createLogger } from "../shared/logger.js";
 import {
   getMarkdownTheme,
   withFileMutationQueue,
@@ -29,26 +30,20 @@ import {
 import { Type } from "typebox";
 import { type AgentConfig, type AgentScope, discoverAgents } from "./agents.js";
 
-// Import TaskStore for taskId validation (bypasses raw file reads)
-let TaskStoreClass: any = null;
-(async () => {
-  const candidates = [
-    "@tintinweb/pi-tasks/dist/task-store.js",
-    pathToFileURL(path.join(os.homedir(), ".pi/agent/npm/node_modules/@tintinweb/pi-tasks/dist/task-store.js")).href,
-  ];
-  for (const c of candidates) {
-    try { const mod = await import(c); if (mod.TaskStore) { TaskStoreClass = mod.TaskStore; break; } } catch { continue; }
-  }
-  if (!TaskStoreClass) {
-    throw new Error("[subagent] FATAL: TaskStore not found — @tintinweb/pi-tasks is required but failed to load");
-  }
-})();
+// Task store access via shared instance from extensions/pitasks
+let _taskStore: any = null;
+async function getTaskStore(): Promise<any> {
+  if (_taskStore) return _taskStore;
+  try { const mod = await import("../pitasks/index.js"); _taskStore = mod.taskStore; } catch { /* ignore */ }
+  return _taskStore;
+}
 import {
   decideAsyncLlmDispatch,
   supportsAsyncLlm,
 } from "./async-capability.js";
 import { autoMarkInProgress, autoCompleteTask } from "./async-agents.js";
 import { getSetting } from "./project-settings.js";
+import { checkSyncLimit } from "./sync-limit.js";
 import { substituteSettingsPlaceholders } from "./rule-placeholders.js";
 import { resolveAgentModelProvider } from "./resolve-agent-model.js";
 import { parseModelOverride, mergeModelOverride } from "./parse-model-override.js";
@@ -61,7 +56,7 @@ const SETTINGS_KEYS_FOR_SUBAGENT = JSON.parse(
   ),
 );
 
-export { resolveAgentModelProvider, parseModelOverride };
+export { resolveAgentModelProvider, parseModelOverride, checkSyncLimit };
 
 // ── Constants ────────────────────────────────────────────────────────────
 
@@ -69,11 +64,19 @@ const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
 const COLLAPSED_ITEM_COUNT = 10;
 const MISSING_CWD_ERROR = "Missing required parameter: cwd. Always specify the working directory for subagent tasks.";
-const MAX_SYNC_SECONDS = 30;
-const SYNC_TIME_EXCEEDED_ERROR = (seconds: number) =>
-  `Estimated time ${seconds}s meets or exceeds ${MAX_SYNC_SECONDS}s sync limit. Use async: true instead.`;
+// Resolved per-call from settings
+const log = createLogger("subagent");
+const SYNC_TIME_EXCEEDED_ERROR = (seconds: number, limit: number, cwd: string) => {
+  log.info("sync_time_exceeded", "seconds", seconds, "limit", limit, "cwd", cwd);
+  return `Estimated time ${seconds}s meets or exceeds ${limit}s sync limit. Use async: true instead.`;
+};
 const MISSING_ESTIMATE_ERROR = "Missing required parameter: estimatedSeconds. Provide an estimated duration in seconds for sync agent tasks.";
 
+let syncPenalty = 0;
+let lastSyncAgent = "";
+let lastSyncEstimate = 0;
+let lastSyncActual = 0;
+
 /** Agents that MUST be dispatched with async: true. Sync calls are rejected.
  *  Keep in sync with rules/20-code-review-loop.md when changing this list. */
 const ASYNC_ONLY_AGENTS = new Set([
@@ -474,13 +477,14 @@ export async function runSingleAgent(
     args.push(`Task: ${task}`);
     let aborted = false;
 
+    log.info("sync_spawn_start", agentName, "cwd", cwd);
     const exitCode = await new Promise<number>((resolve) => {
       const inv = getPiInvocation(args);
       const proc = spawn(inv.command, inv.args, {
         cwd: cwd,
         shell: false,
         stdio: ["ignore", "pipe", "pipe"],
-        env: { ...process.env, PI_SUBAGENT_CHILD: "1", PI_AGENT_NAME: agentName },
+        env: { ...process.env, PI_SUBAGENT_CHILD: "1", PI_AGENT_NAME: agentName, PI_PRIMARY_MODEL: process.env.PI_PRIMARY_MODEL || process.env.PI_MODEL || "", __PI_CONFIG_SESSION_ID: (globalThis as any).__piConfigSessionId || "", __PI_PARENT_SESSION_ID: (globalThis as any).__piConfigSessionId || "" },
       });
       let buf = "";
 
@@ -528,10 +532,14 @@ export async function runSingleAgent(
         cur.stderr += d.toString();
       });
       proc.on("close", (c) => {
+        log.info("sync_proc_close", agentName, "code", c);
         if (buf.trim()) processLine(buf);
         resolve(c ?? 0);
       });
-      proc.on("error", () => resolve(1));
+      proc.on("error", (err) => {
+        log.error("sync_proc_error", agentName, err?.message);
+        resolve(1);
+      });
 
       if (signal) {
         const kill = () => {
@@ -546,6 +554,7 @@ export async function runSingleAgent(
       }
     });
 
+    log.info("sync_proc_resolved", agentName, "exitCode", exitCode, "elapsed", Date.now() - startTime);
     cur.exitCode = exitCode;
     cur.durationMs = Date.now() - startTime;
 
@@ -563,32 +572,21 @@ export async function runSingleAgent(
   }
 }
 
-/** Validate that a taskId references an existing task in the pi-tasks store. */
-function validateTaskId(taskId: string, cwd: string, sessionId?: string): string | null {
+/** Validate that a taskId references an existing task in the pitasks store. */
+function validateTaskId(taskId: string, _cwd: string, _sessionId?: string): string | null {
   if (taskId === "-1") return null;
-
-  const tasksDir = path.join(cwd, ".pi", "tasks");
-  const paths: string[] = [];
-  if (sessionId) paths.push(path.join(tasksDir, `tasks-${sessionId}.json`));
-  paths.push(path.join(tasksDir, "tasks.json"));
-
-  for (const p of paths) {
-    try {
-      if (TaskStoreClass) {
-        const store = new TaskStoreClass(p);
-        if (store.get(taskId)) return null;
-      } else {
-        // Fallback: raw file read when TaskStore hasn't loaded yet (async init race)
-        const data = JSON.parse(fs.readFileSync(p, "utf-8"));
-        if ((data.tasks || []).some((t: any) => t.id === taskId)) return null;
-      }
-    } catch (e: any) {
-      // Only continue silently for missing files; report other errors
-      if (e?.code === "ENOENT" || e?.message?.includes("ENOENT")) continue;
-      return `Task store error for ${path.basename(p)}: ${e?.message || e}. Fix the task store or pass taskId: "-1".`;
+  try {
+    // Ensure store is loaded (async init may not have completed)
+    if (!_taskStore) {
+      getTaskStore().catch(() => {});
     }
-  }
-
+    const store = _taskStore;
+    if (!store) {
+      // Store not loaded yet (async init) — fail open, skip validation
+      return null;
+    }
+    if (store.get(taskId)) return null;
+  } catch { return null; }
   return `Task #${taskId} not found. Verify the task ID exists (use TaskList to check), or pass taskId: "-1" if not linked to a task.`;
 }
 
@@ -766,6 +764,10 @@ export function registerSubagentTool(
         };
       }
     }
+    if (syncPenalty > 0) {
+      log.info("sync_penalty_reset", "async used");
+      syncPenalty = 0;
+    }
     const result = spawnAsyncAgent(params.agent, params.task, params.cwd, agents, {
       fireAndForget: params.fireAndForget,
       name: params.name,
@@ -840,9 +842,25 @@ export function registerSubagentTool(
     }
     // chain runs sequentially — sum all steps
     const totalChainSeconds = params.chain.reduce((sum: number, s: any) => sum + s.estimatedSeconds, 0);
-    if (totalChainSeconds >= MAX_SYNC_SECONDS && asyncOk) {
+    if (!params.chain || params.chain.length === 0) {
+      return { content: [{ type: "text" as const, text: "Error: chain array is empty — at least one step is required." }] };
+    }
+    const chainCwd = params.chain[0].cwd;
+    const { limit: chainLimit } = checkSyncLimit(0, chainCwd);
+    if (syncPenalty > 0) {
+      const adjustedTotal = totalChainSeconds + syncPenalty;
+      if (adjustedTotal >= chainLimit) {
+        log.info("sync_penalty_rejected_chain", "penalty", syncPenalty, "adjusted", adjustedTotal);
+        return {
+          content: [{ type: "text" as const, text: `Rejected: your last sync agent '${lastSyncAgent}' estimated ${lastSyncEstimate}s but took ${lastSyncActual}s. Penalty: ${syncPenalty}s. Chain total ${totalChainSeconds}s + penalty ${syncPenalty}s = ${adjustedTotal}s — exceeds ${chainLimit}s limit. Use async: true.` }],
+          details: mkd("chain")([]),
+          isError: true,
+        };
+      }
+    }
+    if (totalChainSeconds >= chainLimit && asyncOk) {
       return {
-        content: [{ type: "text" as const, text: SYNC_TIME_EXCEEDED_ERROR(totalChainSeconds) }],
+        content: [{ type: "text" as const, text: SYNC_TIME_EXCEEDED_ERROR(totalChainSeconds, chainLimit, chainCwd) }],
         details: mkd("chain")([]),
         isError: true,
       };
@@ -965,9 +983,22 @@ export function registerSubagentTool(
     }
     // parallel runs concurrently — use longest task
     const maxParallelSeconds = Math.max(...params.tasks.map((t: any) => t.estimatedSeconds!));
-    if (maxParallelSeconds >= MAX_SYNC_SECONDS && asyncOk) {
+    const parallelCwd = params.tasks[0]?.cwd ?? process.cwd();
+    const { limit: parallelLimit } = checkSyncLimit(0, parallelCwd);
+    if (syncPenalty > 0) {
+      const adjustedMax = maxParallelSeconds + syncPenalty;
+      if (adjustedMax >= parallelLimit) {
+        log.info("sync_penalty_rejected_parallel", "penalty", syncPenalty, "adjusted", adjustedMax);
+        return {
+          content: [{ type: "text" as const, text: `Rejected: your last sync agent '${lastSyncAgent}' estimated ${lastSyncEstimate}s but took ${lastSyncActual}s. Penalty: ${syncPenalty}s. Max parallel estimate ${maxParallelSeconds}s + penalty ${syncPenalty}s = ${adjustedMax}s — exceeds ${parallelLimit}s limit. Use async: true.` }],
+          details: mkd("parallel")([]),
+          isError: true,
+        };
+      }
+    }
+    if (maxParallelSeconds >= parallelLimit && asyncOk) {
       return {
-        content: [{ type: "text" as const, text: SYNC_TIME_EXCEEDED_ERROR(maxParallelSeconds) }],
+        content: [{ type: "text" as const, text: SYNC_TIME_EXCEEDED_ERROR(maxParallelSeconds, parallelLimit, parallelCwd) }],
         details: mkd("parallel")([]),
         isError: true,
       };
@@ -1127,9 +1158,21 @@ export function registerSubagentTool(
         isError: true,
       };
     }
-    if (params.estimatedSeconds >= MAX_SYNC_SECONDS && asyncOk) {
+    const { limit: singleLimit } = checkSyncLimit(0, params.cwd);
+    if (syncPenalty > 0) {
+      const adjustedEstimate = (params.estimatedSeconds ?? 0) + syncPenalty;
+      if (adjustedEstimate >= singleLimit) {
+        log.info("sync_penalty_rejected", params.agent, "estimate", params.estimatedSeconds, "penalty", syncPenalty, "adjusted", adjustedEstimate);
+        return {
+          content: [{ type: "text" as const, text: `Rejected: your last sync agent '${lastSyncAgent}' estimated ${lastSyncEstimate}s but took ${lastSyncActual}s. Penalty: ${syncPenalty}s. Your estimate ${params.estimatedSeconds}s + penalty ${syncPenalty}s = ${adjustedEstimate}s — exceeds ${singleLimit}s limit. Use async: true.` }],
+          details: mkd("single")([]),
+          isError: true,
+        };
+      }
+    }
+    if (params.estimatedSeconds >= singleLimit && asyncOk) {
       return {
-        content: [{ type: "text" as const, text: SYNC_TIME_EXCEEDED_ERROR(params.estimatedSeconds) }],
+        content: [{ type: "text" as const, text: SYNC_TIME_EXCEEDED_ERROR(params.estimatedSeconds, singleLimit, params.cwd) }],
         details: mkd("single")([]),
         isError: true,
       };
@@ -1142,6 +1185,8 @@ export function registerSubagentTool(
     if (syncTaskId && syncTaskId !== "-1") {
       await autoMarkInProgress(syncTaskId, params.cwd, sessionId).catch(() => {});
     }
+    log.info("sync_execute_start", params.agent, "taskId", syncTaskId ?? "none");
+    const syncStartTime = Date.now();
     const r = await runSingleAgent(
       agents,
       params.agent,
@@ -1156,6 +1201,15 @@ export function registerSubagentTool(
       params.persistSession,
       explicit,
     );
+    const actualSeconds = Math.round((Date.now() - syncStartTime) / 1000);
+    if (actualSeconds > checkSyncLimit(0, params.cwd).limit && actualSeconds - (params.estimatedSeconds ?? 0) > 30) {
+      syncPenalty = actualSeconds - (params.estimatedSeconds ?? 0);
+      lastSyncAgent = params.agent;
+      lastSyncEstimate = params.estimatedSeconds ?? 0;
+      lastSyncActual = actualSeconds;
+      log.info("sync_penalty_set", params.agent, "estimate", params.estimatedSeconds, "actual", actualSeconds, "penalty", syncPenalty);
+    }
+    log.info("sync_execute_done", params.agent, "exitCode", r.exitCode, "stopReason", r.stopReason, "elapsed", Date.now() - syncStartTime);
     activeAgents.delete(label);
     updateWorking();
     const err =
@@ -1177,6 +1231,7 @@ export function registerSubagentTool(
     if (syncTaskId && syncTaskId !== "-1") {
       await autoCompleteTask(syncTaskId, params.cwd, sessionId).catch(() => {});
     }
+    log.info("sync_execute_returning", params.agent);
     return {
       content: [
         { type: "text" as const, text: getFinalOutput(r.messages) || "(no output)" },

package/extensions/orchestrator/sync-limit.ts

@@ -0,0 +1,23 @@
+/**
+ * Sync agent time-limit helpers.
+ * Kept separate from subagent-tool so unit tests can import without heavy deps.
+ */
+
+import { getSetting } from "./project-settings.js";
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("subagent");
+
+/**
+ * Check if estimated seconds exceed the sync limit for a given cwd.
+ * Exported for testing.
+ */
+export function checkSyncLimit(
+  estimatedSeconds: number,
+  cwd: string,
+): { exceeded: boolean; limit: number } {
+  const raw = getSetting(cwd, "sync_agent_max_seconds");
+  const limit = typeof raw === "number" && raw > 0 ? raw : 60; // fallback to default
+  log.debug("checkSyncLimit", "estimated", estimatedSeconds, "limit", limit, "exceeded", estimatedSeconds >= limit);
+  return { exceeded: estimatedSeconds >= limit, limit };
+}

package/extensions/orchestrator/task-lifecycle.ts

@@ -1,88 +1,98 @@
 /**
- * Task lifecycle helpers — auto-complete / mark in_progress via pi-tasks TaskStore.
- * Kept separate from async-agents.ts so unit tests can import without loading
- * @earendil-works/pi-coding-agent (unavailable in the tsx test harness).
+ * Task lifecycle helpers — auto-complete / mark in_progress via owned taskStore.
+ * Uses the exported store instance from extensions/pitasks when available.
+ * Falls back to _storeFactory for unit testing.
  */
 
-import * as os from "node:os";
 import * as path from "node:path";
-import { pathToFileURL } from "node:url";
+import { createLogger } from "../shared/logger.js";
 
-let TaskStoreClass: any = null;
-const taskStoreReady: Promise<void> = (async () => {
-  const candidates = [
-    "@tintinweb/pi-tasks/dist/task-store.js",
-    pathToFileURL(path.join(os.homedir(), ".pi/agent/npm/node_modules/@tintinweb/pi-tasks/dist/task-store.js")).href,
-  ];
-  for (const candidate of candidates) {
-    try {
-      const mod = await import(candidate);
-      if (mod.TaskStore) { TaskStoreClass = mod.TaskStore; break; }
-    } catch { continue; }
-  }
-  if (!TaskStoreClass) {
-    throw new Error("[task-lifecycle] FATAL: TaskStore not found — @tintinweb/pi-tasks is required but failed to load");
-  }
-})();
+const log = createLogger("task-lifecycle");
 
-/** Auto-complete a task via pi-tasks TaskStore (in-process, no AI involvement). */
+/** Get the shared task store instance (lazy import to avoid circular deps). */
+async function getStore(): Promise<any> {
+  // Don't cache — pitasks reassigns taskStore during session upgrade/switch.
+  // Always read the latest export.
+  try {
+    const mod = await import("../pitasks/index.js");
+    return mod.taskStore ?? null;
+  } catch { return null; }
+}
+
+/** Auto-complete a task (in-process, no AI involvement). */
 export async function autoCompleteTask(taskId: string, cwd: string, sessionId?: string, _storeFactory?: (path: string) => any): Promise<boolean> {
   if (!taskId || taskId === "-1") return false;
-  await taskStoreReady;
-
-  const tasksDir = path.join(cwd, ".pi", "tasks");
-  const candidates: string[] = [];
-  if (sessionId) candidates.push(path.join(tasksDir, `tasks-${sessionId}.json`));
-  candidates.push(path.join(tasksDir, "tasks.json"));
 
-  for (const storePath of candidates) {
-    try {
-      const factory = _storeFactory ?? ((p: string) => new TaskStoreClass(p));
-      const store = factory(storePath);
-      const task = store.get(taskId);
-      if (task) {
-        // Task found in this store — do not fall through to later candidates
-        if (task.status !== "completed") {
-          store.update(taskId, { status: "completed" });
-          return true;
+  // TEST-ONLY: _storeFactory constructs file paths for unit test isolation.
+  // Production code NEVER passes this — it falls through to getStore() below.
+  if (_storeFactory) {
+    const tasksDir = path.join(cwd, ".pi", "tasks");
+    const candidates: string[] = [];
+    if (sessionId) candidates.push(path.join(tasksDir, `tasks-${sessionId}.json`));
+    candidates.push(path.join(tasksDir, "tasks.json"));
+    for (const storePath of candidates) {
+      let store: any;
+      try {
+        store = _storeFactory(storePath);
+        const task = store.get(taskId);
+        if (task) {
+          if (task.status !== "completed") { store.update(taskId, { status: "completed" }); return true; }
+          return false;
         }
-        return false;
-      }
-    } catch (e: any) {
-      console.debug(`[task-lifecycle] autoCompleteTask failed for task ${taskId}: ${e?.message?.slice(0, 100)}`);
-      continue;
+      } catch { continue; }
+      finally { if (store && typeof store.close === "function") store.close(); }
     }
+    return false;
+  }
+
+  const store = await getStore();
+  if (!store) return false;
+  try {
+    const task = store.get(taskId);
+    if (!task) return false;
+    if (task.status !== "completed") { store.update(taskId, { status: "completed" }); return true; }
+    return false;
+  } catch (e: any) {
+    log.debug("autoCompleteTask failed for task", taskId, e?.message?.slice(0, 100));
+    return false;
   }
-  return false;
 }
 
-/** Auto-mark a task in_progress via pi-tasks TaskStore (in-process, no AI involvement). */
+/** Auto-mark a task in_progress (in-process, no AI involvement). */
 export async function autoMarkInProgress(taskId: string, cwd: string, sessionId?: string, _storeFactory?: (path: string) => any): Promise<boolean> {
   if (!taskId || taskId === "-1") return false;
-  await taskStoreReady;
-
-  const tasksDir = path.join(cwd, ".pi", "tasks");
-  const candidates: string[] = [];
-  if (sessionId) candidates.push(path.join(tasksDir, `tasks-${sessionId}.json`));
-  candidates.push(path.join(tasksDir, "tasks.json"));
 
-  for (const storePath of candidates) {
-    try {
-      const factory = _storeFactory ?? ((p: string) => new TaskStoreClass(p));
-      const store = factory(storePath);
-      const task = store.get(taskId);
-      if (task) {
-        // Task found in this store — do not fall through to later candidates
-        if (task.status === "pending") {
-          store.update(taskId, { status: "in_progress" });
-          return true;
+  // TEST-ONLY: _storeFactory constructs file paths for unit test isolation.
+  // Production code NEVER passes this — it falls through to getStore() below.
+  if (_storeFactory) {
+    const tasksDir = path.join(cwd, ".pi", "tasks");
+    const candidates: string[] = [];
+    if (sessionId) candidates.push(path.join(tasksDir, `tasks-${sessionId}.json`));
+    candidates.push(path.join(tasksDir, "tasks.json"));
+    for (const storePath of candidates) {
+      let store: any;
+      try {
+        store = _storeFactory(storePath);
+        const task = store.get(taskId);
+        if (task) {
+          if (task.status === "pending") { store.update(taskId, { status: "in_progress" }); return true; }
+          return false;
         }
-        return false;
-      }
-    } catch (e: any) {
-      console.debug(`[task-lifecycle] autoMarkInProgress failed for task ${taskId}: ${e?.message?.slice(0, 100)}`);
-      continue;
+      } catch { continue; }
+      finally { if (store && typeof store.close === "function") store.close(); }
     }
+    return false;
+  }
+
+  const store = await getStore();
+  if (!store) return false;
+  try {
+    const task = store.get(taskId);
+    if (!task) return false;
+    if (task.status === "pending") { store.update(taskId, { status: "in_progress" }); return true; }
+    return false;
+  } catch (e: any) {
+    log.debug("autoMarkInProgress failed for task", taskId, e?.message?.slice(0, 100));
+    return false;
   }
-  return false;
 }

package/extensions/orchestrator/utils.ts

@@ -4,11 +4,8 @@
 
 import { execFile, execFileSync } from "node:child_process";
 import * as fs from "node:fs";
-import { createRequire } from "node:module";
 import * as path from "node:path";
 
-const require = createRequire(import.meta.url);
-
 /** Whether notify-send is available (false = ENOENT, never retry) */
 let notifyAvailable: boolean | undefined;
 
@@ -91,7 +88,7 @@ export function resolveRepoRoot(cwd: string): string {
 
 /** Resolve to the current worktree root (or repo root if not in a worktree).
  *  Uses --show-toplevel → returns THIS worktree's root, not the shared repo root.
- *  Use for per-worktree resources: pi-config-review-state.json.
+ *  Use for per-worktree resources: pi-config-review-state.jsonl.
  *  For non-worktree repos, returns the same as resolveRepoRoot.
  *  @param cwd — Directory to resolve from (any path inside the worktree)
  *  @returns The worktree's top-level directory, or `cwd` as fallback */
@@ -151,7 +148,7 @@ export function tryGetSystemPromptOptions(ctx: any): { contextFiles?: any[]; ski
 }
 
 /** Minimum pi version required by this pi-config version. */
-export const MIN_PI_VERSION = "0.81.0";
+export const MIN_PI_VERSION = "0.84.0";
 
 /** Get the installed pi version from its package.json. */
 export function getPiVersion(): string | null {
@@ -225,3 +222,9 @@ export function isPiMetaInvocation(argv: string[] = process.argv): boolean {
   }
   return sawMeta;
 }
+
+export {
+  isPiOneshotInvocation,
+  shouldSkipOneshotRegister,
+  shouldSkipOneshotShutdownDream,
+} from "../shared/oneshot.js";