@jwilger/pi-development-system 0.10.6 → 0.12.0

package/src/subagents/orch/paths.ts

@@ -0,0 +1,74 @@
+// @ts-nocheck: vendored upstream pi-subagent-manager 0.14.0 compiled under looser options; see src/subagents/VENDORED.md
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+
+const SEGMENT = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+export function canonicalPath(value: string, caller = "/root"): string {
+  if (!value || value !== value.trim())
+    throw new Error("Agent path must not be empty or contain surrounding whitespace");
+  const path = value.startsWith("/") ? value : `${caller}/${value}`;
+  const parts = path.slice(1).split("/");
+  if (!parts.every((part) => SEGMENT.test(part)) || parts.length > 32) {
+    throw new Error(
+      "Agent paths require slash-separated names (letters, digits, - or _); no dot segments, escapes, empty segments or trailing slash",
+    );
+  }
+  return path;
+}
+export function parentPath(path: string): string | null {
+  canonicalPath(path);
+  const last = path.lastIndexOf("/");
+  return last === 0 ? null : path.slice(0, last);
+}
+export function isDescendant(path: string, ancestor: string): boolean {
+  return path.startsWith(`${ancestor}/`);
+}
+
+/** Snapshot conversation, not the parent's prompt/loadout; retain only matched tool exchanges. */
+export function inheritContext(messages: readonly AgentMessage[]): AgentMessage[] {
+  const copy = structuredClone(messages);
+  const matchedCalls = new Set<string>();
+  const matchedResults = new Set<number>();
+  const pending = new Map<string, { messageIndex: number; blockIndex: number }[]>();
+
+  for (const [messageIndex, message] of copy.entries()) {
+    if (message.role === "assistant") {
+      if (message.stopReason === "error" || message.stopReason === "aborted") continue;
+      for (const [blockIndex, block] of message.content.entries()) {
+        if (block.type !== "toolCall") continue;
+        const queue = pending.get(block.id);
+        const occurrence = { messageIndex, blockIndex };
+        if (queue) queue.push(occurrence);
+        else pending.set(block.id, [occurrence]);
+      }
+      continue;
+    }
+    if (message.role !== "toolResult") continue;
+    const queue = pending.get(message.toolCallId);
+    const occurrence = queue?.shift();
+    if (!occurrence) continue;
+    matchedCalls.add(`${occurrence.messageIndex}:${occurrence.blockIndex}`);
+    matchedResults.add(messageIndex);
+    if (queue && !queue.length) pending.delete(message.toolCallId);
+  }
+
+  return copy.flatMap((message, messageIndex): AgentMessage[] => {
+    // Only the system prompt/loadout is replaced; custom and shell messages are real conversation context.
+    if (message.role === "system") return [];
+    if (message.role === "assistant") {
+      if (message.stopReason === "error" || message.stopReason === "aborted") return [];
+      message.content = message.content.filter(
+        (block, blockIndex) =>
+          block.type !== "toolCall" || matchedCalls.has(`${messageIndex}:${blockIndex}`),
+      );
+      if (!message.content.length) return [];
+      // A tools-only assistant without remaining calls should not claim a toolUse stop.
+      if (
+        message.stopReason === "toolUse" &&
+        !message.content.some((block) => block.type === "toolCall")
+      )
+        message.stopReason = "stop";
+    }
+    if (message.role === "toolResult" && !matchedResults.has(messageIndex)) return [];
+    return [message];
+  });
+}

package/src/subagents/orch/prompt.ts

@@ -0,0 +1,25 @@
+// @ts-nocheck: vendored upstream pi-subagent-manager 0.14.0 compiled under looser options; see src/subagents/VENDORED.md
+import type { ManagerSettings } from "../prefs/settings.ts";
+
+/** Root-only guidance: child SDK sessions use their own worker prompt. */
+export function subagentPrompt(settings: ManagerSettings): string | undefined {
+  if (settings.subagentMode === "off") return undefined;
+  const policy =
+    settings.subagentMode === "orchestration"
+      ? "Orchestration mode: /root only coordinates. Delegate every user task to subagents, even small or sequential tasks. Do not inspect/edit files, run commands, research, or execute task work yourself. Only plan, assign, monitor, clarify, and synthesize subagent results for the user. This restriction applies only to /root; subagents execute the work."
+      : "Opportunistic mode: do ordinary tasks yourself. Delegate only when work can be parallelized, is long-running, or is very large; do not spawn agents for small, quick, straightforward tasks.";
+  const waitingPolicy =
+    settings.subagentMode === "orchestration"
+      ? "As an orchestrator, you must NEVER be blocked waiting for subagents. ALWAYS start every subagent in async/background mode with wait:false, even for small or sequential tasks. NEVER call agent_wait or use a foreground spawn. End your turn after assigning work so you remain free to talk to the user while subagents work. Check agent_status and collect available results with agent_output without blocking; if results are not ready, report that and leave the conversation free."
+      : "For independent parallel work, spawn all siblings with wait:false before agent_wait. Only await synchronous tasks whose results are needed in the current turn. For long-running tasks, create background agents with wait:false and do not immediately call agent_wait; end your turn so you remain free to talk to the user while they work. Await background results when the user asks you to collect them.";
+  return [
+    "## pi-subagent",
+    "You are /root, the main conversation (L1).",
+    policy,
+    "Call agent_types before choosing a type. Use task-based kebab-case paths, not type names. Choose context via agent_spawn path: /root/task forks the lexical parent's conversation; /task starts fresh with no inherited history. Use fresh agents for adversarial review or clean-slate research; give them a self-contained task without the current thread's conclusions.",
+    waitingPolicy,
+    "Use agent_status to inspect and agent_output for full results. Detached notifications do not resume your turn.",
+    "Use agent_steer to send input or resume retained sessions. Paused agents have no final answer; completed agents hand back results. Both retain their session.",
+    `Maximum depth: ${settings.maxLevels} levels including L1. Shared concurrency: ${settings.maxConcurrent} active threads; waiting parents count.`,
+  ].join("\n");
+}