@bermudi/pi-delegate 0.1.0 → 0.1.2

package/task-resolution.ts

@@ -1,6 +1,10 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import { DEFAULT_TOOLS, VALID_THINKING } from "./constants.ts";
+import {
+  DEFAULT_AGENT_NAME,
+  DEFAULT_TOOLS,
+  VALID_THINKING,
+} from "./constants.ts";
 import { TOOL_FACTORIES, resolveToolGroups } from "./tools.ts";
 import { configFor } from "./pool.ts";
 import { isSessionBusy } from "./tickets.ts";
@@ -14,10 +18,54 @@ import type {
   AgentConfig,
   DelegateToolCtx,
   DelegateToolResult,
+  ParentAgentDefaults,
   ResolvedTask,
   TaskDef,
 } from "./types.ts";
 
+const PROJECT_CONTEXT_START =
+  "\n\n<project_context>\n\nProject-specific instructions and guidelines:\n\n";
+const PROJECT_CONTEXT_END = "\n</project_context>\n";
+
+/**
+ * Parent `getSystemPrompt()` is the fully assembled prompt, including the
+ * parent's AGENTS.md files. A delegated session resolves resources for its own
+ * cwd, so carrying that section across would leak global instructions and
+ * duplicate project context. Preserve the parent's base prompt and everything
+ * outside Pi's structured context section; the child ResourceLoader appends its
+ * own (filtered) context afterward.
+ *
+ * The AGENTS.md/CLAUDE.md content is inserted verbatim inside
+ * `<project_instructions>...</project_instructions>` blocks. A file that
+ * itself contains `\n</project_context>\n` can therefore forge an early
+ * closing marker. It could also include a forged `</project_instructions>` to
+ * balance the open tag, making the fake `</project_context>` look like the
+ * section end. A content-controlled marker can only ever appear *inside* the
+ * generated `<project_context>` block, before the real `</project_context>`
+ * that Pi appends after the last file. Skills escape angle brackets, the
+ * `appendSystemPrompt` text is added before this section, and the trailing
+ * `Current working directory:` line contains no such marker, so the real
+ * closing marker is the final raw `\n</project_context>\n` in the prompt.
+ * We therefore match the Pi-generated opening marker to the final matching
+ * closing marker, deterministically stripping the whole generated section.
+ */
+export function stripInheritedProjectContext(
+  prompt: string | undefined,
+): string | undefined {
+  if (!prompt) return prompt;
+
+  const start = prompt.indexOf(PROJECT_CONTEXT_START);
+  if (start < 0) return prompt;
+
+  // The real closing marker is the final occurrence: child content cannot
+  // place a `</project_context>` after the one Pi generates to close the
+  // section.
+  const end = prompt.lastIndexOf(PROJECT_CONTEXT_END);
+  if (end < start) return prompt;
+
+  return `${prompt.slice(0, start)}${prompt.slice(end + PROJECT_CONTEXT_END.length)}`;
+}
+
 /** Build a tool result for an error/notice with no task progress. */
 function noticeResult(
   text: string,
@@ -30,6 +78,11 @@ function noticeResult(
   };
 }
 
+/** Format a task reference for error messages: one-based index with an optional caller id. */
+function formatTaskRef(index: number, id: string | undefined): string {
+  return `Task ${index + 1}${id ? `#${id}` : ""}`;
+}
+
 /** Pre-dispatch validation: duplicate sessionIds, sessions busy with an async
  *  ticket, and unknown agent names. Returns an error result to short-circuit
  *  the call, or null when all checks pass. */
@@ -65,12 +118,32 @@ export function validateTasks(
     );
   }
 
+  // Disallow duplicate caller-provided task ids within one dispatch.
+  const seenIds = new Map<string, number>();
+  const duplicateIds: string[] = [];
+  for (const [index, task] of tasks.entries()) {
+    if (task.id) {
+      if (seenIds.has(task.id)) {
+        duplicateIds.push(
+          `task ${index + 1}: duplicate id '${task.id}' — ids must be unique within one dispatch.`,
+        );
+      } else {
+        seenIds.set(task.id, index);
+      }
+    }
+  }
+  if (duplicateIds.length) {
+    return noticeResult(duplicateIds.join(" "), tasks, parentModelId);
+  }
+
   const unknown: string[] = [];
   for (const t of tasks) {
-    if (t.agent && !agents.has(t.agent)) unknown.push(t.agent);
+    if (t.agent && t.agent !== DEFAULT_AGENT_NAME && !agents.has(t.agent)) {
+      unknown.push(t.agent);
+    }
   }
   if (unknown.length) {
-    const names = [...agents.keys()];
+    const names = [DEFAULT_AGENT_NAME, ...agents.keys()];
     return noticeResult(
       `Unknown agent(s): ${unknown.join(", ")}. Available: ${names.join(", ") || "(none)"}. Call delegate with an empty tasks array for help.`,
       tasks,
@@ -89,6 +162,7 @@ export function resolveTasks(
   tasks: TaskDef[],
   ctx: DelegateToolCtx,
   agents: Map<string, AgentConfig>,
+  parentDefaults: ParentAgentDefaults,
 ): ResolvedTask[] {
   // Build parent transcript lazily — only computed once if any task uses with-parent-transcript
   let parentTranscript: string | null = null;
@@ -107,54 +181,104 @@ export function resolveTasks(
     );
   }
 
-  const parentSystemPrompt = ctx.getSystemPrompt?.();
+  const parentSystemPrompt = stripInheritedProjectContext(
+    ctx.getSystemPrompt?.(),
+  );
 
   return tasks.map((t, i) => {
-    const agent = t.agent ? agents.get(t.agent) : undefined;
+    const isDefaultAgent = t.agent === DEFAULT_AGENT_NAME;
+    const agent = t.agent && !isDefaultAgent ? agents.get(t.agent) : undefined;
     const cwd = resolveCwd(t.cwd ?? ctx.cwd, ctx.cwd);
 
     // Load settings-based overrides for this agent
     const settings = loadDelegateSettings(cwd);
     const agentOverride =
-      t.agent && settings?.agentOverrides?.[t.agent]
+      t.agent && !isDefaultAgent && settings?.agentOverrides?.[t.agent]
         ? settings.agentOverrides[t.agent]
         : undefined;
 
     // Build system prompt. Explicit task prompts and named agent prompts
-    // win; ad-hoc subagents inherit the parent prompt when Pi exposes it,
-    // then get explicit skills/AGENTS.md injection below.
+    // win; ad-hoc subagents inherit the parent's base prompt when Pi exposes
+    // it. The assembled parent project-context section was stripped above;
+    // the child ResourceLoader supplies context for this task's cwd.
     const pooledConfig = t.sessionId ? configFor(t.sessionId) : undefined;
+    const isPoolHit = pooledConfig !== undefined;
+    const parentNativeTools = parentDefaults.tools.filter((name) =>
+      Object.hasOwn(TOOL_FACTORIES, name),
+    );
+    let tools: string[] = [];
+    const warnings: string[] = [];
 
     // Prompt is required for fresh tasks. ResumeFrom provides context already.
     if (
-      t.action !== "close" &&
-      t.action !== "list" &&
+      t.sessionAction !== "close" &&
+      t.sessionAction !== "list" &&
       !t.resumeFrom &&
       !t.prompt?.trim()
     ) {
       throw new Error(
-        `Task ${i}: prompt is required unless action is 'close'/'list' or resumeFrom is set.`,
+        `${formatTaskRef(i, t.id)}: prompt is required unless sessionAction is 'close'/'list' or resumeFrom is set.`,
       );
     }
 
+    // Resolve tools — warn about unknown tool names.
+    // For active pooled sessions, fall back to the frozen pooled config so
+    // "continue with only sessionId" works without re-supplying tools.
+    // Explicit overrides that don't match get rejected by acquireAgentSession.
+    if (t.sessionAction !== "close" && t.sessionAction !== "list") {
+      tools = resolveToolGroups(
+        t.tools ??
+          agentOverride?.tools ??
+          agent?.tools ??
+          (isDefaultAgent ? parentNativeTools : undefined) ??
+          (isPoolHit ? pooledConfig?.tools : undefined) ??
+          DEFAULT_TOOLS,
+      );
+      const unknownTools = tools.filter(
+        (name) => !Object.hasOwn(TOOL_FACTORIES, name),
+      );
+      if (unknownTools.length) {
+        warnings.push(
+          `Unknown tool(s) ignored: ${unknownTools.join(", ")}. Available: ${Object.keys(TOOL_FACTORIES).join(", ")}`,
+        );
+      }
+      tools = tools.filter((name) => Object.hasOwn(TOOL_FACTORIES, name));
+    }
+
     // System prompt resolution. AgentSession's resource loader owns
-    // skills + AGENTS.md discovery (it appends them via _rebuildSystemPrompt),
-    // so we resolve only the *base* prompt here: explicit task prompt → named
-    // agent body → parent session prompt → default. The resolved base is
-    // passed as the loader's customPrompt (see buildDelegateSession).
-    // Keep explicit intent separate: a bare `{ prompt, sessionId }` continues
-    // the frozen prompt even if the parent prompt has since changed, while an
-    // explicit task/profile prompt must not be silently ignored on reuse.
+    // skills + project AGENTS.md discovery (it appends them via
+    // _rebuildSystemPrompt), so we resolve only the *base* prompt here:
+    // explicit task prompt → named agent body → sanitized parent prompt →
+    // default. The resolved base is passed as the loader's customPrompt (see
+    // buildDelegateSession).
+    //
+    // The *requested* system prompt is what the reuse check compares against the
+    // frozen pooled value. A bare `{ prompt, sessionId }` omits it so the pool
+    // can keep using the frozen prompt even if the parent prompt changed. An
+    // explicit task/profile prompt is used as-is. The built-in `default` profile
+    // intentionally mirrors the live parent, so its requested prompt is the
+    // *sanitized* parent prompt — the same form that would be stored as the
+    // frozen base, avoiding a false mismatch when the inherited default prompt
+    // gets its stale tool inventory stripped.
+    const resolvedBasePrompt = buildSubagentSystemPrompt({
+      taskSystemPrompt: t.systemPrompt,
+      agentSystemPrompt: agent?.systemPrompt,
+      parentSystemPrompt,
+      tools,
+    });
     const requestedSystemPrompt = t.systemPrompt?.trim()
       ? t.systemPrompt
       : agent?.systemPrompt?.trim()
         ? agent.systemPrompt
-        : undefined;
+        : isDefaultAgent
+          ? resolvedBasePrompt
+          : undefined;
     const systemPrompt = buildSubagentSystemPrompt({
       taskSystemPrompt: t.systemPrompt,
       agentSystemPrompt: agent?.systemPrompt,
       parentSystemPrompt,
       pooledSystemPrompt: pooledConfig?.systemPrompt,
+      tools,
     });
 
     // Build prompt — wrap with parent context if using with-parent-transcript
@@ -186,46 +310,49 @@ export function resolveTasks(
     let model: Model<Api> | undefined;
     let requestedModel: Model<Api> | undefined;
     let modelSuffix: ThinkingLevel | undefined;
-    let tools: string[] = [];
     let thinking: ThinkingLevel = "off";
-    const warnings: string[] = [];
 
-    if (t.action !== "close" && t.action !== "list") {
+    if (t.sessionAction !== "close" && t.sessionAction !== "list") {
       // A pool hit always runs its frozen model, but an explicitly requested
       // task/profile model still has to be resolved so checkout can reject a
-      // contradictory request rather than silently discarding it.
+      // contradictory request rather than silently discarding it. Naming the
+      // built-in `default` profile is also explicit: it requests the live
+      // parent model, so reuse fails clearly if the pool was frozen differently.
       if (pooledConfig) {
         const requestedModelSpec =
           t.model ??
-          (t.agent ? (agentOverride?.model ?? agent?.model) : undefined);
+          (t.agent && !isDefaultAgent
+            ? (agentOverride?.model ?? agent?.model)
+            : undefined);
         if (requestedModelSpec) {
-          requestedModel = resolveModelRequest(
+          const requested = resolveModelRequest(
             requestedModelSpec,
             ctx.modelRegistry,
             ctx.model,
-          ).model;
+          );
+          requestedModel = requested.model;
+          modelSuffix = requested.strippedSuffix;
           if (!requestedModel) {
             throw new Error(
-              `Task ${i}: requested model '${requestedModelSpec}' is not available. Check provider config or remove the model field to continue the pooled session.`,
+              `${formatTaskRef(i, t.id)}: requested model '${requestedModelSpec}' is not available. Check provider config or remove the model field to continue the pooled session.`,
             );
           }
+        } else if (isDefaultAgent) {
+          requestedModel = ctx.model;
         }
         model = pooledConfig.model;
       } else {
-        // Resolve an explicit model spec (precedence: task > session > config >
-        // frontmatter). resolveModelSpec returns undefined when none is set, so
-        // we skip model re-resolution entirely — passing the parent's composite id
-        // (e.g. OpenRouter's "deepseek/deepseek-v4-flash") would split on "/"
-        // and misroute to the upstream provider. Leaving resolvedModel
-        // undefined also lets findAvailableAlternative run below: it returns
-        // ctx.model as-is when it has auth, or swaps to an authenticated
-        // same-id alternative when the parent's provider lost auth.
+        // The built-in `default` profile bypasses delegate.json and settings:
+        // absent a task override, it means this exact live parent Model object.
+        // Other tasks retain the normal task > config > frontmatter chain.
         const agentType = t.agent ?? "inline";
-        const modelSpec = resolveModelSpec({
-          taskModel: t.model ?? agentOverride?.model,
-          agentType,
-          frontmatterModel: agent?.model,
-        });
+        const modelSpec = isDefaultAgent
+          ? t.model
+          : resolveModelSpec({
+              taskModel: t.model ?? agentOverride?.model,
+              agentType,
+              frontmatterModel: agent?.model,
+            });
         const resolvedRequest = modelSpec
           ? resolveModelRequest(modelSpec, ctx.modelRegistry, ctx.model)
           : undefined;
@@ -234,56 +361,46 @@ export function resolveTasks(
         // it is honored only as a last-resort thinking default (see below).
         modelSuffix = resolvedRequest?.strippedSuffix;
 
-        // If the task or settings explicitly set a model but it couldn't resolve, fail loudly
-        const explicitRequest = t.model ?? agentOverride?.model;
+        // The selected model spec is explicit regardless of whether it came
+        // from the task, settings, or named-agent frontmatter. If it cannot
+        // resolve, fail loudly instead of silently falling back to the parent.
+        const explicitRequest = modelSpec;
         if (explicitRequest && !resolvedModel) {
           throw new Error(
-            `Task ${i}: requested model '${explicitRequest}' is not available. Check provider config or remove the model field to use the parent model.`,
+            `${formatTaskRef(i, t.id)}: requested model '${explicitRequest}' is not available. Check provider config or remove the model field to use the parent model.`,
           );
         }
 
-        model =
-          resolvedModel ??
-          findAvailableAlternative(ctx.model, ctx.modelRegistry) ??
-          ctx.model;
+        model = isDefaultAgent
+          ? (resolvedModel ?? ctx.model)
+          : (resolvedModel ??
+            findAvailableAlternative(ctx.model, ctx.modelRegistry) ??
+            ctx.model);
       }
 
       if (!model) {
         throw new Error(
-          `Task ${i}: no model available — parent session has no model set.`,
+          `${formatTaskRef(i, t.id)}: no model available — parent session has no model set.`,
         );
       }
 
-      // Resolve tools — warn about unknown tool names.
-      // For active pooled sessions, fall back to the frozen pooled config so
-      // "continue with only sessionId" works without re-supplying tools.
-      // Explicit overrides that don't match get rejected by acquireAgentSession.
-      const isPoolHit = pooledConfig !== undefined;
-      tools = resolveToolGroups(
-        t.tools ??
-          agentOverride?.tools ??
-          agent?.tools ??
-          (isPoolHit ? pooledConfig?.tools : undefined) ??
-          DEFAULT_TOOLS,
-      );
-      const unknownTools = tools.filter((name) => !(name in TOOL_FACTORIES));
-      if (unknownTools.length) {
-        warnings.push(
-          `Unknown tool(s) ignored: ${unknownTools.join(", ")}. Available: ${Object.keys(TOOL_FACTORIES).join(", ")}`,
-        );
-      }
-
-      // Resolve thinking. Precedence: task field → agent override → agent
-      // frontmatter → frozen pooled config → a Pi-style `:level` model suffix
-      // (honored only as a last-resort default, so a model-emitted `claude:max`
-      // runs at max when nothing else sets thinking). The suffix is lowest on
-      // purpose: an agent author's `thinking: low` must beat `model: x:max`.
+      // Resolve thinking. Precedence for most agents: explicit `thinking` >
+      // agent override > frontmatter > frozen pooled config > model `:level`
+      // suffix (last resort). The built-in `default` agent intentionally
+      // inverts the last two steps: model suffix beats the parent's live
+      // thinking, which beats the frozen pooled value. This surfaces a clear
+      // `config mismatch` error on reuse when the parent thinking level has
+      // changed, rather than silently reusing a stale frozen value. The final
+      // pooled fallback is reachable only when parentDefaults.thinking is
+      // undefined (headless parent without a thinking level).
       const thinkingRaw =
         t.thinking ??
         agentOverride?.thinking ??
         agent?.thinking ??
-        (isPoolHit ? pooledConfig?.thinking : undefined) ??
+        (isPoolHit && !isDefaultAgent ? pooledConfig?.thinking : undefined) ??
         modelSuffix ??
+        (isDefaultAgent ? parentDefaults.thinking : undefined) ??
+        (isPoolHit ? pooledConfig?.thinking : undefined) ??
         "off";
       thinking = VALID_THINKING.has(thinkingRaw)
         ? (thinkingRaw as ThinkingLevel)
@@ -299,6 +416,7 @@ export function resolveTasks(
     }
     return {
       ...t,
+      id: t.id,
       cwd,
       systemPrompt,
       model: model!,
@@ -307,10 +425,11 @@ export function resolveTasks(
       // Empty only for close/list actions (validated above) — downstream
       // display code treats "" and absent alike (`t.prompt || …`).
       prompt: prompt ?? "",
-      // Display label for ad-hoc subagents (no named profile). NOTE: the
-      // config-namespace key at resolveModelSpec stays "inline" — that's a
-      // delegate.json/settings contract, not a display string (friction #4).
-      agentName: agent?.name ?? "ad-hoc",
+      // Keep the built-in selector visible in progress/results. Omitted-agent
+      // inline tasks retain the established `ad-hoc` label and config namespace.
+      agentName: isDefaultAgent
+        ? DEFAULT_AGENT_NAME
+        : (agent?.name ?? "ad-hoc"),
       warnings,
       reuseIntent: {
         model: requestedModel,