pi-orchestrator-config 4.2.0 → 4.3.2

package/extensions/orchestrator/subagent-tool.ts

@@ -6,7 +6,7 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 import { createRequire } from "node:module";
 
@@ -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,29 +30,33 @@ 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";
 import { clockHHMM, getPiInvocation, getProjectTmpDir, djb2Hash } from "./utils.js";
 
-export { resolveAgentModelProvider };
+const SETTINGS_KEYS_FOR_SUBAGENT = JSON.parse(
+  fs.readFileSync(
+    path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "settings-keys.json"),
+    "utf-8",
+  ),
+);
+
+export { resolveAgentModelProvider, parseModelOverride, checkSyncLimit };
 
 // ── Constants ────────────────────────────────────────────────────────────
 
@@ -59,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([
@@ -82,6 +95,7 @@ const TaskItem = Type.Object({
   name: Type.Optional(Type.String({ description: "Display name for async status" })),
   estimatedSeconds: Type.Optional(Type.Number({ description: "Estimated task duration in seconds. Required for sync parallel tasks." })),
   taskId: Type.Optional(Type.String({ description: "Task ID to auto-complete when this async agent finishes" })),
+  model: Type.Optional(Type.String({ description: "Override the agent's model. Format: 'provider/model-id' or 'model-id'." })),
 });
 const ChainItem = Type.Object({
   agent: Type.String({ description: "Agent name" }),
@@ -141,6 +155,9 @@ const SubagentParams = Type.Object({
   persistSession: Type.Optional(
     Type.Boolean({ description: "Persist agent session to disk for reuse across calls. Default: false (ephemeral). When true, the same agent in the same project reuses its session — keeps context, saves tokens." }),
   ),
+  model: Type.Optional(
+    Type.String({ description: "Override the agent's model. Format: 'provider/model-id' (e.g., 'litellm/claude-opus-4-6-1m') or just 'model-id' (inherits provider). Overrides all other model resolution." }),
+  ),
 });
 
 // ── Interfaces ───────────────────────────────────────────────────────────
@@ -370,6 +387,7 @@ export async function runSingleAgent(
   parentModelId?: string,
   parentProvider?: string,
   persistSession?: boolean,
+  explicit?: { model?: string; provider?: string },
 ): Promise<SingleResult> {
   const agent = agents.find((a) => a.name === agentName);
   if (!agent) {
@@ -401,7 +419,7 @@ export async function runSingleAgent(
     // Deterministic session ID based on agent + cwd for session reuse
     args.push("--session-id", `sync-${agentName}-${djb2Hash(agentName + ':' + cwd).toString(36)}`);
   }
-  const { model: effectiveModel, provider: effectiveProvider } = resolveAgentModelProvider(agentName, agent, parentModelId, parentProvider, cwd);
+  const { model: effectiveModel, provider: effectiveProvider } = resolveAgentModelProvider(agentName, agent, parentModelId, parentProvider, cwd, explicit);
   if (effectiveModel) args.push("--model", effectiveModel);
   if (effectiveProvider) args.push("--provider", effectiveProvider);
   if (agent.tools && agent.tools.length > 0)
@@ -446,7 +464,12 @@ export async function runSingleAgent(
 
   try {
     if (agent.systemPrompt.trim()) {
-      const tmp = await writePromptFile(agent.name, agent.systemPrompt, cwd);
+      const resolvedPrompt = substituteSettingsPlaceholders(
+        agent.systemPrompt,
+        (key) => getSetting(cwd, key as any),
+        Object.keys(SETTINGS_KEYS_FOR_SUBAGENT),
+      );
+      const tmp = await writePromptFile(agent.name, resolvedPrompt, cwd);
       tmpDir = tmp.dir;
       tmpFile = tmp.filePath;
       args.push("--append-system-prompt", tmpFile);
@@ -454,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 = "";
 
@@ -508,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 = () => {
@@ -526,8 +554,10 @@ export async function runSingleAgent(
       }
     });
 
+    log.info("sync_proc_resolved", agentName, "exitCode", exitCode, "elapsed", Date.now() - startTime);
     cur.exitCode = exitCode;
     cur.durationMs = Date.now() - startTime;
+
     if (aborted) throw new Error("Subagent was aborted");
     return cur;
   } finally {
@@ -542,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.`;
 }
 
@@ -575,7 +594,7 @@ function validateTaskId(taskId: string, cwd: string, sessionId?: string): string
 
 export function registerSubagentTool(
   pi: ExtensionAPI,
-  spawnAsyncAgent: (agentName: string, task: string, cwd: string, agents: AgentConfig[], options?: { fireAndForget?: boolean; name?: string; parentModelId?: string; parentProvider?: string; groupId?: string; taskId?: string }) => { id: string; error?: string; model?: string },
+  spawnAsyncAgent: (agentName: string, task: string, cwd: string, agents: AgentConfig[], options?: { fireAndForget?: boolean; name?: string; parentModelId?: string; parentProvider?: string; groupId?: string; taskId?: string; persistSession?: boolean; explicit?: { model?: string; provider?: string } }) => { id: string; error?: string; model?: string },
   killAsyncAgent: (target: string) => { killed: string[]; errors: string[] },
 ): void {
   // Only the orchestrator (top-level pi) can spawn subagents.
@@ -606,6 +625,7 @@ export function registerSubagentTool(
     parentModelId: string | undefined,
     parentProvider: string | undefined,
     ctx: any,
+    explicit?: { model?: string; provider?: string },
   ) {
     if (params.chain) {
       return {
@@ -664,6 +684,7 @@ export function registerSubagentTool(
         ? `group-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
         : undefined;
       for (const t of params.tasks) {
+        const taskExplicit = mergeModelOverride(t.model, explicit);
         const r = spawnAsyncAgent(t.agent, t.task, t.cwd, agents, {
           fireAndForget: params.fireAndForget,
           name: (t as any).name,
@@ -672,6 +693,7 @@ export function registerSubagentTool(
           groupId,
           taskId: (t as any).taskId,
           persistSession: params.persistSession,
+          explicit: taskExplicit,
         });
         if (r.error) {
           errors.push(`${t.agent}: ${r.error}`);
@@ -742,7 +764,19 @@ export function registerSubagentTool(
         };
       }
     }
-    const result = spawnAsyncAgent(params.agent, params.task, params.cwd, agents, { fireAndForget: params.fireAndForget, name: params.name, parentModelId, parentProvider, taskId: params.taskId, persistSession: params.persistSession });
+    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,
+      parentModelId,
+      parentProvider,
+      taskId: params.taskId,
+      persistSession: params.persistSession,
+      explicit: explicit,
+    });
     if (result.error) {
       return {
         content: [{ type: "text" as const, text: result.error }],
@@ -770,6 +804,7 @@ export function registerSubagentTool(
     parentProvider: string | undefined,
     asyncOk: boolean,
     sessionId?: string,
+    explicit?: { model?: string; provider?: string },
   ) {
     const results: SingleResult[] = [];
     let prev = "";
@@ -807,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,
       };
@@ -848,6 +899,7 @@ export function registerSubagentTool(
         parentModelId,
         parentProvider,
         params.persistSession,
+        explicit,
       );
       activeAgents.delete(s.agent);
       updateWorking();
@@ -899,6 +951,7 @@ export function registerSubagentTool(
     parentProvider: string | undefined,
     asyncOk: boolean,
     sessionId?: string,
+    explicit?: { model?: string; provider?: string },
   ) {
     if (params.tasks.length > MAX_PARALLEL_TASKS)
       return {
@@ -930,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,
       };
@@ -997,6 +1063,7 @@ export function registerSubagentTool(
         const label = t.name || t.agent;
         activeAgents.add(label);
         updateWorking();
+        const taskExplicit = mergeModelOverride(t.model, explicit);
         const r = await runSingleAgent(
           agents,
           t.agent,
@@ -1014,6 +1081,7 @@ export function registerSubagentTool(
           parentModelId,
           parentProvider,
           params.persistSession,
+          taskExplicit,
         );
         all[i] = r;
         activeAgents.delete(t.name || t.agent);
@@ -1062,6 +1130,7 @@ export function registerSubagentTool(
     parentProvider: string | undefined,
     asyncOk: boolean,
     sessionId?: string,
+    explicit?: { model?: string; provider?: string },
   ) {
     if (!params.cwd) {
       return {
@@ -1089,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,
       };
@@ -1104,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,
@@ -1116,7 +1199,17 @@ export function registerSubagentTool(
       parentModelId,
       parentProvider,
       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 =
@@ -1138,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)" },
@@ -1451,6 +1545,8 @@ export function registerSubagentTool(
       const confirm = params.confirmProjectAgents ?? true;
       let parentModelId = ctx.model?.id as string | undefined;
       let parentProvider = ctx.model?.provider as string | undefined;
+      // Parse explicit model override from params (applies to all execution modes)
+      const explicitOverride = parseModelOverride(params.model);
       const asyncOk = supportsAsyncLlm(parentProvider, ctx.cwd);
       let capabilityNote = "";
 
@@ -1577,9 +1673,11 @@ export function registerSubagentTool(
         }
       }
 
+      const explicit = explicitOverride;
+
       // Async mode — spawn in background and return immediately
       if (params.async === true) {
-        const result = executeAsync(params, agents, mkd, parentModelId, parentProvider, ctx);
+        const result = executeAsync(params, agents, mkd, parentModelId, parentProvider, ctx, explicit);
         if (capabilityNote && result.content?.[0]?.type === "text") {
           result.content[0].text = `${capabilityNote}\n\n${result.content[0].text}`;
         }
@@ -1600,21 +1698,21 @@ export function registerSubagentTool(
       // Chain mode
       if (params.chain && params.chain.length > 0) {
         return withCapabilityNote(
-          await executeChain(params, agents, mkd, signal, onUpdate, activeAgents, updateWorking, parentModelId, parentProvider, asyncOk, sessionId),
+          await executeChain(params, agents, mkd, signal, onUpdate, activeAgents, updateWorking, parentModelId, parentProvider, asyncOk, sessionId, explicit),
         );
       }
 
       // Parallel mode
       if (params.tasks && params.tasks.length > 0) {
         return withCapabilityNote(
-          await executeParallel(params, agents, mkd, signal, onUpdate, activeAgents, updateWorking, parentModelId, parentProvider, asyncOk, sessionId),
+          await executeParallel(params, agents, mkd, signal, onUpdate, activeAgents, updateWorking, parentModelId, parentProvider, asyncOk, sessionId, explicit),
         );
       }
 
       // Single mode
       if (params.agent && params.task) {
         return withCapabilityNote(
-          await executeSingle(params, agents, mkd, signal, onUpdate, activeAgents, updateWorking, parentModelId, parentProvider, asyncOk, sessionId),
+          await executeSingle(params, agents, mkd, signal, onUpdate, activeAgents, updateWorking, parentModelId, parentProvider, asyncOk, sessionId, explicit),
         );
       }
 

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;
 }