pi-subagents 0.82.1 → 0.83.1

package/src/agents/agent-management.js

@@ -6,7 +6,7 @@ import { mergeAgentsForScope } from "./agent-selection.js";
 import { discoverAvailableSkills, resolveSkills } from "./skills.js";
 import { buildProactiveSkillSubagentRecommendationLines, } from "./proactive-skills.js";
 import { parseFrontmatter, parseUnquotedList } from "./frontmatter.js";
-import { resolveEffectiveThinking, toModelInfo } from "../shared/model-info.js";
+import { resolveEffectiveThinking, THINKING_LEVELS, toModelInfo } from "../shared/model-info.js";
 import { resolveSubagentModelOverride } from "../runs/shared/model-resolution.js";
 import { validateToolBudgetConfig } from "../runs/shared/tool-budget.js";
 import { formatReviewGateLabel, validateAcceptanceInput } from "../runs/shared/acceptance.js";
@@ -279,11 +279,8 @@ export function preservedAgentFrontmatterFields(agent, cfg) {
         changed("subagentOnlyExtensions");
     if (hasKey(cfg, "mutationTools"))
         changed("mutationTools");
-    if (hasKey(cfg, "thinking")) {
+    if (hasKey(cfg, "thinking"))
         changed("thinking");
-        if (cfg.thinking === "off")
-            fields.add("thinking");
-    }
     if (hasKey(cfg, "systemPromptMode")) {
         changed("systemPromptMode");
         fields.add("systemPromptMode");
@@ -528,17 +525,14 @@ function applyAgentConfig(target, cfg) {
             return "config.mutationTools must be a comma-separated string, empty string, or false when provided.";
     }
     if (hasKey(cfg, "thinking")) {
-        if (cfg.thinking === false || cfg.thinking === "")
+        const thinking = typeof cfg.thinking === "string" ? cfg.thinking.trim() : cfg.thinking;
+        const level = THINKING_LEVELS.find((candidate) => candidate === thinking);
+        if (thinking === false || thinking === "")
             delete target.thinking;
-        else if (typeof cfg.thinking === "string") {
-            const thinking = cfg.thinking.trim();
-            if (thinking)
-                target.thinking = thinking;
-            else
-                delete target.thinking;
-        }
+        else if (level)
+            target.thinking = level;
         else
-            return "config.thinking must be a string or false when provided.";
+            return `config.thinking must be one of ${THINKING_LEVELS.join(", ")}, or false when provided.`;
     }
     if (hasKey(cfg, "systemPromptMode")) {
         if (cfg.systemPromptMode === "append" || cfg.systemPromptMode === "replace")
@@ -1029,7 +1023,7 @@ export function handleList(params, ctx) {
     let scopedAgents = effectiveAgentsForScope(scope, d, ctx.runtimeAgentOwner, ctx.model?.provider);
     scopedAgents = scopedAgents
         .sort((a, b) => a.name.localeCompare(b.name));
-    const capabilityCeiling = resolveCurrentSubagentCapabilityCeiling(ctx.currentSessionId);
+    const capabilityCeiling = resolveCurrentSubagentCapabilityCeiling(ctx.piSessionId);
     const visibleAgents = scopedAgents.filter((a) => !a.disabled);
     const agents = visibleAgents.filter((a) => isAgentAllowedByCapabilityCeiling(a.name, capabilityCeiling));
     const restrictedAgents = visibleAgents.filter((a) => !isAgentAllowedByCapabilityCeiling(a.name, capabilityCeiling));
@@ -1088,7 +1082,7 @@ function handleModels(params, ctx) {
     const availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo);
     const currentModel = ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined;
     const preferredProvider = ctx.model?.provider;
-    const capabilityCeiling = resolveCurrentSubagentCapabilityCeiling(ctx.currentSessionId);
+    const capabilityCeiling = resolveCurrentSubagentCapabilityCeiling(ctx.piSessionId);
     let selectedAgents = effectiveAgents;
     if (requestedAgent) {
         const matches = findAgentsInDiscovery(requestedAgent, discovered, scope, ctx.runtimeAgentOwner, ctx.model?.provider);

package/src/agents/agent-serializer.js

@@ -91,9 +91,8 @@ export function serializeAgent(config, options = {}) {
         lines.push(`model: ${config.model ?? ""}`);
     if (config.fast === true || preserve("fast"))
         lines.push(`fast: ${config.fast === undefined ? "" : config.fast ? "true" : "false"}`);
-    if ((config.thinking && (config.thinking !== "off" || preserve("thinking"))) || (!config.thinking && preserve("thinking"))) {
+    if (config.thinking || preserve("thinking"))
         lines.push(`thinking: ${config.thinking ?? ""}`);
-    }
     if (!preservingExistingFrontmatter || preserve("systemPromptMode"))
         lines.push(`systemPromptMode: ${config.systemPromptMode}`);
     if (!preservingExistingFrontmatter || preserve("inheritProjectContext"))

package/src/agents/agents.js

@@ -28,6 +28,7 @@ import { parseMemoryFrontmatter } from "./agent-memory.js";
 import { validateAcceptanceInput } from "../runs/shared/acceptance.js";
 import { validatePermissionRules } from "../runs/shared/permissions.js";
 import { parseThinkingLevel } from "../shared/thinking-ceiling.js";
+import { THINKING_LEVELS } from "../shared/model-info.js";
 import { assertJsonSchemaObject } from "../runs/shared/structured-output.js";
 import { normalizeCapabilityCeilingAllowedAgents } from "../runs/shared/capability-ceiling.js";
 export function defaultSystemPromptMode(name) {
@@ -39,6 +40,14 @@ export function defaultInheritProjectContext(name) {
 export function defaultInheritSkills() {
     return false;
 }
+/** Every field an `agentOverrides` entry may set; the Record type keeps it equal to BuiltinAgentOverrideConfig. */
+const BUILTIN_OVERRIDE_FIELDS = {
+    description: true, advertise: true, machine: true, output: true, outputMode: true, defaultReads: true, model: true,
+    defaultProvider: true, fast: true, thinking: true, systemPromptMode: true, inheritProjectContext: true,
+    inheritGlobalContext: true, inheritSkills: true, defaultContext: true, acceptanceRole: true, disabled: true,
+    systemPrompt: true, skills: true, tools: true, excludeTools: true, allowNestedSubagents: true, allowedAgents: true,
+    extensions: true, subagentOnlyExtensions: true, mutationTools: true, toolBudget: true,
+};
 const EMPTY_SUBAGENT_SETTINGS = { overrides: {}, providerOverrides: {} };
 const agentFrontmatterFields = new WeakMap();
 const AGENT_SOURCE_PRIORITY = {
@@ -763,6 +772,12 @@ function parseBuiltinOverrideEntry(name, value, filePath) {
     if (Object.hasOwn(input, "launcher")) {
         throw new Error(`Builtin override '${name}' in '${filePath}' sets 'launcher', which settings overrides do not support; set 'launcher' in a user agent file instead.`);
     }
+    for (const key of Object.keys(input)) {
+        if (Object.hasOwn(BUILTIN_OVERRIDE_FIELDS, key))
+            continue;
+        const suggestion = closestMatch(key, Object.keys(BUILTIN_OVERRIDE_FIELDS));
+        throw new Error(`Builtin override '${name}' in '${filePath}' has unknown field '${key}'.${suggestion ? ` Did you mean '${suggestion}'?` : ""}`);
+    }
     const override = {};
     if ("description" in input) {
         if (typeof input.description === "string" && input.description.trim()) {
@@ -805,10 +820,11 @@ function parseBuiltinOverrideEntry(name, value, filePath) {
             throw new Error(`Builtin override '${name}' in '${filePath}' has invalid 'fast'; expected a boolean.`);
     }
     if ("thinking" in input) {
-        if (typeof input.thinking === "string" || input.thinking === false)
-            override.thinking = input.thinking;
+        const level = THINKING_LEVELS.find((candidate) => candidate === input.thinking);
+        if (level !== undefined || input.thinking === false)
+            override.thinking = level ?? false;
         else
-            throw new Error(`Builtin override '${name}' in '${filePath}' has invalid 'thinking'; expected a string or false.`);
+            throw new Error(`Builtin override '${name}' in '${filePath}' has invalid 'thinking'; expected one of ${THINKING_LEVELS.join(", ")}, or false.`);
     }
     if ("systemPromptMode" in input) {
         if (input.systemPromptMode === "append" || input.systemPromptMode === "replace") {
@@ -2416,8 +2432,7 @@ function buildAgentDiscoverySources(cwd, preferredModelProvider, globalNpmRoot,
     const watchPaths = new Set([
         userSettingsPath,
         ...(projectSettingsPath ? [projectSettingsPath] : []),
-        ...projectDiscoveryWatchPaths(effectiveCwd),
-        ...findProjectRootCandidates(effectiveCwd).map((root) => path.join(getProjectConfigDir(root), "settings.json")),
+        ...(projectTrusted ? [...projectDiscoveryWatchPaths(effectiveCwd), ...findProjectRootCandidates(effectiveCwd).map((root) => path.join(getProjectConfigDir(root), "settings.json"))] : []),
         ...userScanDirs.watchPaths,
         ...projectScanDirs.watchPaths,
         ...packageSubagentPaths.watchPaths,

package/src/agents/frontmatter.js

@@ -97,22 +97,15 @@ export function parseFrontmatter(content) {
         // neither end a pending list block nor become part of its value.
         if (trimmed.startsWith("#") && !currentFolded && !currentLiteral)
             continue;
-        if (currentKey !== null && currentBlockLines !== null && (indent > (currentIndent ?? 0) || ((currentFolded || currentLiteral) && trimmed === ""))) {
+        // Exactly-empty lines belong to any pending block, not only to | and > scalars.
+        if (currentKey !== null && currentBlockLines !== null && (indent > (currentIndent ?? 0) || trimmed === "")) {
             // This line is part of the current block value
             currentBlockLines.push(line);
             continue;
         }
         // Flush any pending block value
         if (currentKey !== null && currentBlockLines !== null) {
-            // Strip the common leading whitespace from the block so the
-            // serializer can add its own indentation level.
-            const rawBlock = currentBlockLines.join("\n");
-            const leadingSpaces = rawBlock.match(/^[ \t]+(?=\S)/m);
-            const prefix = leadingSpaces?.[0] ?? "";
-            const stripped = prefix
-                ? rawBlock.replace(new RegExp(`^${escapeRegex(prefix)}`, "gm"), "").replace(/^\n/, "")
-                : rawBlock;
-            frontmatter[currentKey] = currentFolded ? foldBlock(stripped) : stripped;
+            frontmatter[currentKey] = flushBlockLines(currentBlockLines, currentFolded, currentLiteral);
             currentKey = null;
             currentBlockLines = null;
             currentIndent = null;
@@ -146,17 +139,28 @@ export function parseFrontmatter(content) {
                 frontmatter[key] = value;
             }
         }
-        // Lines that don't match a key pattern (e.g., comments, empty lines) are ignored
     }
     // Flush final block value
     if (currentKey !== null && currentBlockLines !== null) {
-        const rawBlock = currentBlockLines.join("\n");
-        const leadingSpaces = rawBlock.match(/^[ \t]+(?=\S)/m);
-        const prefix = leadingSpaces?.[0] ?? "";
-        const stripped = prefix
-            ? rawBlock.replace(new RegExp(`^${escapeRegex(prefix)}`, "gm"), "").replace(/^\n/, "")
-            : rawBlock;
-        frontmatter[currentKey] = currentFolded ? foldBlock(stripped) : stripped;
+        frontmatter[currentKey] = flushBlockLines(currentBlockLines, currentFolded, currentLiteral);
     }
     return { frontmatter, body };
 }
+function flushBlockLines(blockLines, folded, literal) {
+    let lines = blockLines;
+    if (!folded && !literal) {
+        // Drop exactly-empty edge lines, and every line from the first exactly-empty one after
+        // the last content line, so nested values without inner blank lines parse as before.
+        const end = lines.indexOf("", lines.findLastIndex((line) => line.trim() !== "") + 1);
+        lines = lines.slice(lines.findIndex((line) => line !== ""), end < 0 ? lines.length : end);
+    }
+    // Strip the common leading whitespace from the block so the
+    // serializer can add its own indentation level.
+    const rawBlock = lines.join("\n");
+    const leadingSpaces = rawBlock.match(/^[ \t]+(?=\S)/m);
+    const prefix = leadingSpaces?.[0] ?? "";
+    const stripped = prefix
+        ? rawBlock.replace(new RegExp(`^${escapeRegex(prefix)}`, "gm"), "").replace(/^\n/, "")
+        : rawBlock;
+    return folded ? foldBlock(stripped) : stripped;
+}

package/src/api/background-work.d.ts

@@ -4,14 +4,13 @@ export interface BackgroundWorkItem {
     id: string;
     sessionId: string;
 }
-export interface BackgroundWorkReconcileContext {
-    sessionId: string;
-    nowMs: number;
-}
 export interface BackgroundWorkListContext {
     sessionId: string;
+    /** Every form the current session is known by: its file path when it has one, and `getSessionId()`. Includes `sessionId`. */
+    sessionIds: readonly string[];
     nowMs: number;
 }
+export type BackgroundWorkReconcileContext = BackgroundWorkListContext;
 export interface BackgroundWorkProvider {
     name: string;
     listActiveWork(context?: BackgroundWorkListContext): readonly BackgroundWorkItem[];
@@ -34,5 +33,9 @@ export declare function registerBackgroundWorkProvider(provider: BackgroundWorkP
 export declare function listBackgroundWorkProviders(): readonly BackgroundWorkProvider[];
 /** Read validated provider wake channels without reconciling or listing work. */
 export declare function listBackgroundWorkWakeChannels(): readonly string[];
-/** Reconcile and snapshot active provider work owned by one exact Pi session. */
-export declare function snapshotBackgroundWork(sessionId: string, nowMs?: number): BackgroundWorkSnapshot;
+/**
+ * Reconcile and snapshot active provider work owned by one exact Pi session.
+ * `sessionIds` lists that session's identity forms; the first is passed to
+ * providers as `sessionId`, and items keyed by any of them are kept.
+ */
+export declare function snapshotBackgroundWork(sessionIds: readonly string[], nowMs?: number): BackgroundWorkSnapshot;

package/src/api/background-work.js

@@ -4,7 +4,7 @@ const MAX_PROVIDER_NAME_LENGTH = 128;
 const MAX_PROVIDERS = 100;
 const MAX_ITEM_ID_LENGTH = 256;
 /**
- * A Pi session id is the session file path, which routinely exceeds a short
+ * A session can be identified by its file path, which routinely exceeds a short
  * identity budget in nested worktrees, so it is bounded like the other paths.
  */
 const MAX_SESSION_ID_LENGTH = 4_096;
@@ -120,22 +120,29 @@ export function listBackgroundWorkWakeChannels() {
     }
     return [...channels];
 }
-/** Reconcile and snapshot active provider work owned by one exact Pi session. */
-export function snapshotBackgroundWork(sessionId, nowMs = Date.now()) {
-    validateString(sessionId, "Background-work snapshot sessionId", MAX_SESSION_ID_LENGTH);
+/**
+ * Reconcile and snapshot active provider work owned by one exact Pi session.
+ * `sessionIds` lists that session's identity forms; the first is passed to
+ * providers as `sessionId`, and items keyed by any of them are kept.
+ */
+export function snapshotBackgroundWork(sessionIds, nowMs = Date.now()) {
+    const accepted = [...new Set(sessionIds.map((value) => validateString(value, "Background-work snapshot sessionId", MAX_SESSION_ID_LENGTH)))];
+    const sessionId = accepted[0];
+    if (sessionId === undefined)
+        throw new Error("Background-work snapshot needs at least one session id.");
     const providers = listBackgroundWorkProviders();
     const items = [];
     const identities = new Set();
     for (const provider of providers) {
         try {
-            provider.reconcile?.({ sessionId, nowMs });
+            provider.reconcile?.({ sessionId, sessionIds: [...accepted], nowMs });
         }
         catch (error) {
             throw new Error(`Background-work provider '${provider.name}' reconcile failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
         let active;
         try {
-            active = provider.listActiveWork({ sessionId, nowMs });
+            active = provider.listActiveWork({ sessionId, sessionIds: [...accepted], nowMs });
         }
         catch (error) {
             throw new Error(`Background-work provider '${provider.name}' listActiveWork failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
@@ -153,7 +160,7 @@ export function snapshotBackgroundWork(sessionId, nowMs = Date.now()) {
                 throw new Error(`Background-work provider '${provider.name}' returned duplicate item '${item.id}' for session '${item.sessionId}'.`);
             }
             identities.add(identity);
-            if (item.sessionId === sessionId)
+            if (accepted.includes(item.sessionId))
                 items.push({ provider: provider.name, ...item });
         });
     }

package/src/extension/index.js

@@ -566,8 +566,11 @@ export default function registerSubagentExtension(pi) {
     // Pi sends custom messages to the model as plain user messages, so every model-visible
     // pi-subagents message is wrapped in a marker naming its source. The marker depends only on
     // the message, so history renders the same bytes every turn and cached prefixes stay valid.
+    // It runs on context_with_system, not context: Pi treats any change a context handler makes
+    // to the message list as a rewritten conversation and folds every mid-conversation system
+    // message into the leading one, which misses the prompt cache on every later turn.
     const markedMessageTypes = new Set([...SUBAGENT_MESSAGE_TYPES, "subagent-compaction-resume", SLASH_RESULT_TYPE, SLASH_TEXT_RESULT_TYPE, ADMIN_MESSAGE_TYPE]);
-    pi.on("context", (event) => {
+    pi.on("context_with_system", (event) => {
         const messages = [];
         for (const message of event.messages) {
             if (message.role !== "custom" || !markedMessageTypes.has(message.customType)) {
@@ -732,7 +735,7 @@ export default function registerSubagentExtension(pi) {
             event.systemPromptOptions.sections.active_subagents = activeRuns;
         if (!event.systemPromptOptions.selectedTools.includes("subagent"))
             return;
-        const catalog = buildAdvertisedAgentCatalog(advertisedAgents, resolveCurrentSubagentCapabilityCeiling(sessionId), recordedPromptSection(pi, "advertised_subagents"));
+        const catalog = buildAdvertisedAgentCatalog(advertisedAgents, resolveCurrentSubagentCapabilityCeiling(ctx.sessionManager.getSessionId() ?? undefined), recordedPromptSection(pi, "advertised_subagents"));
         if (catalog)
             event.systemPromptOptions.sections.advertised_subagents = catalog;
     });
@@ -1204,7 +1207,7 @@ export default function registerSubagentExtension(pi) {
         hasPendingSupervisorRequest: () => [...supervisorChannel.pending.values()].some((request) => request.expectsReply),
         advertisedPrompt: async () => {
             await waitForAdvertisement();
-            return buildAdvertisedAgentPrompt(advertisedAgents, resolveCurrentSubagentCapabilityCeiling(state.currentSessionId ?? undefined));
+            return buildAdvertisedAgentPrompt(advertisedAgents, resolveCurrentSubagentCapabilityCeiling(state.supervisorOwnerSessionId ?? undefined));
         },
     });
 }

package/src/extension/public-execution.d.ts

@@ -57,8 +57,8 @@ export type PublicSubagentExecutionNormalization<T> = {
 /** A workflow value containing "/" or "\" is a script path; named workflow resource names contain neither. */
 export declare function isWorkflowScriptPath(workflow: string): boolean;
 /**
- * Model tool calls supply script text only through workflow: true (the reply block) or a script path.
- * workflowScript remains the internal carrier for slash, prompt-workflow, scheduled, RPC, and named-resource launches.
+ * Model tool calls supply script text through workflow: true (the reply block), a script path, or options.script,
+ * which flattenSubagentToolOptions lowers to workflowScript, the internal carrier for every other launch path too.
  */
 export declare function removedModelWorkflowFieldError(params: object): string | undefined;
 export declare function validateWorkflowCapacityOverrides(params: PublicSubagentExecutionParams): string | undefined;

package/src/extension/public-execution.js

@@ -7,8 +7,8 @@ export function isWorkflowScriptPath(workflow) {
     return workflow.includes("/") || workflow.includes("\\");
 }
 /**
- * Model tool calls supply script text only through workflow: true (the reply block) or a script path.
- * workflowScript remains the internal carrier for slash, prompt-workflow, scheduled, RPC, and named-resource launches.
+ * Model tool calls supply script text through workflow: true (the reply block), a script path, or options.script,
+ * which flattenSubagentToolOptions lowers to workflowScript, the internal carrier for every other launch path too.
  */
 export function removedModelWorkflowFieldError(params) {
     if (Object.hasOwn(params, "workflowScript"))
@@ -56,7 +56,7 @@ export function normalizePublicSubagentExecution(params, options = {}) {
         return { ok: false, error: "workflow must be true (the ```js workflow block in this reply), a script path containing '/', or a named workflow resource.", mode: "workflow" };
     }
     const hasNamedWorkflow = typeof workflow === "string" && !isWorkflowScriptPath(workflow);
-    // workflowScript is the internal script carrier; model tool calls cannot set it.
+    // workflowScript is the internal script carrier; model tool calls set it only through options.script.
     if (workflow !== undefined && params.workflowScript !== undefined) {
         return { ok: false, error: "workflow cannot be combined with an internal workflowScript.", mode: "workflow" };
     }

package/src/extension/reply-workflow-script.js

@@ -2,10 +2,9 @@ const WORKFLOW_FENCE = /^```(?:js|javascript) workflow[ \t]*$/;
 const PLAIN_JS_FENCE = /^```(?:js|javascript)[ \t]*$/;
 const OPEN_FENCE = /^(`{3,}|~{3,})/;
 const CLOSE_FENCE = /^(`{3,}|~{3,})[ \t]*$/;
-// Claude 5.x (Opus 5.5, Sonnet 5.5, Fable 5.1) text written after a tool call in the same turn reaches the session only as a
-// server summary, which drops fenced blocks (pi-claude-bridge#35); retrying the block fails again.
-const SUMMARY_NOTE = "On some models, text written after a tool call in the same turn reaches the session only as a summary without code blocks, so for the rest of this turn write the script to a file and pass its path, such as workflow: \"./script.js\".";
-const FILE_FALLBACK = `If the block is in your reply: ${SUMMARY_NOTE}`;
+// Through the Claude Agent SDK (pi-claude-bridge#35), text written after a tool call in the same turn reaches the session
+// only as a server summary, which drops fenced blocks; retrying the block fails again. Tool arguments arrive intact.
+const SUMMARY_NOTE = "On some hosts, text written after a tool call in the same turn reaches the session only as a summary without code blocks, so for the rest of this turn pass the script's source as a tool argument: options: { script: \"...\" } in place of workflow: true, with the call's other fields unchanged.";
 /**
  * Pi persists the whole assistant message before running its tool calls, so the
  * message that issued this subagent call is on the branch and carries the script.
@@ -40,7 +39,7 @@ function scriptFromReply(content) {
     const blocks = tagged.length > 0 ? tagged : plain.length === 1 ? plain : [];
     if (blocks.length !== 1) {
         const untagged = tagged.length === 0 && plain.length > 1 ? ` This reply has ${plain.length} untagged js blocks; open the script's block with the line "\`\`\`js workflow".` : "";
-        return { error: `workflow: true needs one fenced block in the same reply as the tool call, opened with the exact line "\`\`\`js workflow" and closed with "\`\`\`"; found ${tagged.length}.${untagged} ${FILE_FALLBACK}` };
+        return { error: `workflow: true needs one fenced block in the same reply as the tool call, opened with the exact line "\`\`\`js workflow" and closed with "\`\`\`"; found ${tagged.length}.${untagged} If the block is in your reply: ${SUMMARY_NOTE}` };
     }
     const script = blocks[0];
     if (!script.trim())

package/src/extension/rpc.js

@@ -5,7 +5,7 @@ import { deliverAsyncRunStop } from "../runs/foreground/async-stop-action.js";
 import { reconcileAsyncRun } from "../runs/background/stale-run-reconciler.js";
 import { resolveCurrentSessionId } from "../shared/session-identity.js";
 import { ownerSessionIds, ownsRun } from "../runs/shared/run-ownership.js";
-import { DIRS, SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_CHILD_STATUS_EVENT, SUBAGENT_PROCESS_TERMINAL_EVENT, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION, } from "../shared/types.js";
+import { DIRS, SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_ASYNC_STARTED_EVENT, SUBAGENT_CHILD_STATUS_EVENT, SUBAGENT_JOBS_CHANGED_EVENT, SUBAGENT_PROCESS_TERMINAL_EVENT, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION, } from "../shared/types.js";
 import { sanitizeDisplayText, truncateDisplayText } from "../shared/display-text.js";
 import { readStatus } from "../shared/utils.js";
 import { SubagentFlatParams } from "./schemas.js";
@@ -336,8 +336,10 @@ function pingData(ctx, options) {
             request: SUBAGENT_RPC_REQUEST_EVENT,
             replyPrefix: SUBAGENT_RPC_REPLY_EVENT_PREFIX,
             asyncComplete: SUBAGENT_ASYNC_COMPLETE_EVENT,
+            asyncStarted: SUBAGENT_ASYNC_STARTED_EVENT,
             childStatus: SUBAGENT_CHILD_STATUS_EVENT,
             processTerminal: SUBAGENT_PROCESS_TERMINAL_EVENT,
+            jobsChanged: SUBAGENT_JOBS_CHANGED_EVENT,
         },
         session: sessionData(ctx),
     };

package/src/extension/subagent-options.js

@@ -1,5 +1,6 @@
 import { isDeepStrictEqual } from "node:util";
 import { Compile } from "typebox/compile";
+import { Value } from "typebox/value";
 import { closestMatch } from "../shared/edit-distance.js";
 import { removedModelWorkflowFieldError } from "./public-execution.js";
 import { SUBAGENT_OPTION_KEYS, SubagentOptionParams, createSubagentParamsSchema } from "./schemas.js";
@@ -22,6 +23,15 @@ export function flattenSubagentToolOptions(params, disabled) {
     const removedField = removedModelWorkflowFieldError(options);
     if (removedField)
         throw new Error(removedField);
+    // options.script carries script text as a tool argument for hosts that drop the reply's ```js block (SUMMARY_NOTE).
+    const { script, ...rest } = options;
+    if (script !== undefined) {
+        if (typeof script !== "string" || !script.trim())
+            throw new Error("subagent: options.script must be the workflow script's source text.");
+        if (topLevel.workflow !== undefined)
+            throw new Error("subagent: options.script replaces workflow; pass only one of them.");
+        return { ...flattenSubagentToolOptions({ ...topLevel, options: rest }, disabled), workflowScript: script };
+    }
     const entries = Object.entries(options);
     const enabledKeys = SUBAGENT_OPTION_KEYS.filter((key) => !disabled?.params.has(key));
     const unknown = entries.map(([key]) => key).filter((key) => !optionKeys.has(key));
@@ -40,12 +50,15 @@ export function flattenSubagentToolOptions(params, disabled) {
     const disabledKey = entries.find(([key]) => disabled?.params.has(key))?.[0];
     if (disabledKey)
         throw new Error(`subagent option 'options.${disabledKey}' is disabled by config ${disabled.params.get(disabledKey)}.`);
-    if (!optionsValidator.Check(options)) {
-        const errors = [...optionsValidator.Errors(options)].slice(0, 4).map((error) => `options${error.instancePath.replaceAll("/", ".")} ${error.message}`);
+    // Pi converts only the declared top-level parameters ("true" -> true); `options` is an untyped bag in the
+    // tool schema, so its values get the same conversion here. Some providers send nested scalars as strings.
+    const converted = Value.Convert(SubagentOptionParams, structuredClone(options));
+    if (!optionsValidator.Check(converted)) {
+        const errors = [...optionsValidator.Errors(converted)].slice(0, 4).map((error) => `options${error.instancePath.replaceAll("/", ".")} ${error.message}`);
         throw new Error(`subagent: ${errors.join("; ")}.`);
     }
-    const conflicts = entries.filter(([key, value]) => topLevel[key] !== undefined && !isDeepStrictEqual(topLevel[key], value)).map(([key]) => `'${key}'`);
+    const conflicts = Object.entries(converted).filter(([key, value]) => topLevel[key] !== undefined && !isDeepStrictEqual(topLevel[key], value)).map(([key]) => `'${key}'`);
     if (conflicts.length > 0)
         throw new Error(`subagent: ${conflicts.join(", ")} given both at the top level and in options with different values; give each once.`);
-    return { ...topLevel, ...options };
+    return { ...topLevel, ...converted };
 }

package/src/missions/actions.js

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { MISSION_STATUSES, } from "./types.js";
 import { missionStatePath } from "./workflow-state.js";
+import { finishedMissionStatus, missionAcceptanceStatus, readMissionBinding } from "./lifecycle.js";
 import { createMission, listGlobalMissions, listMissions, missionRecordPath, readMission, resolveMissionStoreLocation, updateMission, validateMissionId, } from "./store.js";
 export const MISSION_ACTIONS = [
     "mission.create",
@@ -184,6 +185,7 @@ function validateMissionUpdate(value) {
 }
 function refreshLinkedRunStatus(location, record) {
     const warnings = [];
+    const runAcceptance = [];
     const updates = record.runs.flatMap((run) => {
         if (!run.asyncDir)
             return [];
@@ -207,6 +209,7 @@ function refreshLinkedRunStatus(location, record) {
             warnings.push(`Linked run status '${statusPath}' is missing state`);
             return [];
         }
+        runAcceptance.push({ runId: run.runId, status: missionAcceptanceStatus(status.steps) });
         if (state === run.status)
             return [];
         return [{
@@ -232,7 +235,8 @@ function refreshLinkedRunStatus(location, record) {
                         : states.some((state) => state === "stopped" || state === "rejected" || state === "cancelled")
                             ? "cancelled"
                             : states.length > 0 && states.every((state) => state === "complete" || state === "completed")
-                                ? "completed"
+                                // A run without a binding counts as auto-created.
+                                ? finishedMissionStatus(record, !merged.some((run) => run.asyncDir && readMissionBinding(run.asyncDir)?.autoCreated === false), runAcceptance)
                                 : record.status;
     return { record: updateMission(location, record.id, { status, addRuns: updates }), warnings };
 }
@@ -261,7 +265,8 @@ function formatMission(record) {
             const identity = child.runId ? `${child.key} (${child.runId})` : child.key;
             const heartbeat = child.heartbeat ? `; heartbeat ${child.heartbeat.status ?? child.status}${child.heartbeat.phase ? `/${child.heartbeat.phase}` : ""} at ${child.heartbeat.updatedAt}` : "";
             const recovery = child.sessionPath ? `; session ${child.sessionPath}` : child.artifactPaths.length ? `; artifacts ${child.artifactPaths.length}` : "";
-            lines.push(`  ${identity}: ${child.status}${child.agent ? ` — ${child.agent}` : ""}${child.phase ? ` [${child.phase}]` : ""}; updated ${child.updatedAt}${heartbeat}${recovery}`);
+            const acceptance = child.acceptanceStatus ? `; acceptance ${child.acceptanceStatus}` : "";
+            lines.push(`  ${identity}: ${child.status}${child.agent ? ` — ${child.agent}` : ""}${child.phase ? ` [${child.phase}]` : ""}${acceptance}; updated ${child.updatedAt}${heartbeat}${recovery}`);
         }
     }
     if (record.decisions.length) {

package/src/missions/lifecycle.d.ts

@@ -21,6 +21,7 @@ export interface MissionLaunchParams {
 export interface MissionLaunchBinding {
     missionId: string;
     location: MissionStoreLocation;
+    /** True when the launch made the mission without a `mission` or `missionId` request. */
     autoCreated: boolean;
     announceInContent?: boolean;
 }
@@ -30,6 +31,16 @@ export declare function prepareMissionLaunch(input: {
     config?: MissionStoreConfig;
     ownerSessionId?: string;
 }): MissionLaunchBinding | undefined;
+/** The first unaccepted acceptance status among child results, else the first status found. */
+export declare function missionAcceptanceStatus(results: unknown): string | undefined;
+/**
+ * The status of a mission whose runs all finished successfully. Every path that
+ * completes a mission from run state goes through here.
+ */
+export declare function finishedMissionStatus(record: MissionRecord, autoCreated: boolean, runAcceptance: ReadonlyArray<{
+    runId: string;
+    status: string | undefined;
+}>): "completed" | "waiting";
 export declare function writeMissionAsyncBinding(asyncDir: string, binding: MissionLaunchBinding): void;
 export declare function attachMissionToLaunchResult(input: {
     binding: MissionLaunchBinding;

package/src/missions/lifecycle.js

@@ -50,7 +50,7 @@ export function prepareMissionLaunch(input) {
         ...(mission?.labels ? { labels: mission.labels } : {}),
         ...(input.ownerSessionId ? { ownerSessionId: input.ownerSessionId } : {}),
     }, new Date(), input.config?.retainTerminal);
-    return { missionId: record.id, location, autoCreated: true, announceInContent: true };
+    return { missionId: record.id, location, autoCreated: input.params.mission === undefined, announceInContent: true };
 }
 function toolResultIsError(result) {
     return "isError" in result && result.isError === true;
@@ -67,7 +67,30 @@ function runStatusForResult(result) {
         return "failed";
     return "completed";
 }
-function missionStatusForRun(record, runId, runStatus) {
+/** Acceptance statuses that mean nobody accepted the child's result. */
+const UNACCEPTED_ACCEPTANCE_STATUSES = new Set(["pending", "claimed", "review-required", "rejected"]);
+/** The first unaccepted acceptance status among child results, else the first status found. */
+export function missionAcceptanceStatus(results) {
+    const statuses = (Array.isArray(results) ? results : [])
+        .map((result) => result?.acceptance?.status)
+        .filter((status) => typeof status === "string" && status.trim() !== "");
+    return statuses.find((status) => UNACCEPTED_ACCEPTANCE_STATUSES.has(status)) ?? statuses[0];
+}
+/**
+ * The status of a mission whose runs all finished successfully. Every path that
+ * completes a mission from run state goes through here.
+ */
+export function finishedMissionStatus(record, autoCreated, runAcceptance) {
+    // Nobody is expected to close a mission made by default for an ordinary launch.
+    if (autoCreated)
+        return "completed";
+    if (runAcceptance.some((run) => UNACCEPTED_ACCEPTANCE_STATUSES.has(run.status)))
+        return "waiting";
+    // A run reported here supersedes its older workflow child record.
+    const reported = new Set(runAcceptance.map((run) => run.runId));
+    return record.workflowChildren.some((child) => !reported.has(child.runId) && UNACCEPTED_ACCEPTANCE_STATUSES.has(child.acceptanceStatus)) ? "waiting" : "completed";
+}
+function missionStatusForRun(record, runId, runStatus, acceptanceStatus, autoCreated) {
     if (record.status === "completed" || record.status === "failed" || record.status === "cancelled")
         return record.status;
     if (runStatus === "active" || runStatus === "queued" || runStatus === "running")
@@ -80,7 +103,7 @@ function missionStatusForRun(record, runId, runStatus) {
     if (otherActive)
         return "active";
     if (runStatus === "completed" || runStatus === "complete")
-        return "completed";
+        return finishedMissionStatus(record, autoCreated, [{ runId, status: acceptanceStatus }]);
     if (runStatus === "stopped" || runStatus === "rejected" || runStatus === "cancelled")
         return "cancelled";
     return "failed";
@@ -129,6 +152,7 @@ function persistedBinding(binding) {
         globalIndexDir: binding.location.globalIndexDir,
         writeGlobalIndex: binding.location.writeGlobalIndex,
         ...(binding.location.retainTerminal !== undefined ? { retainTerminal: binding.location.retainTerminal } : {}),
+        autoCreated: binding.autoCreated,
     };
 }
 export function writeMissionAsyncBinding(asyncDir, binding) {
@@ -170,7 +194,7 @@ export function attachMissionToLaunchResult(input) {
         ...(usage ? { usage } : {}),
     };
     let mission = updateMission(input.binding.location, input.binding.missionId, {
-        status: missionStatusForRun(current, runId, runStatus),
+        status: missionStatusForRun(current, runId, runStatus, missionAcceptanceStatus(input.result.details.results), input.binding.autoCreated),
         addRuns: [run],
         addArtifacts: artifactsForResult(input.result),
         ...(firstText(input.result) && runStatus !== "active" ? { summary: firstText(input.result) } : {}),
@@ -188,6 +212,8 @@ export function attachMissionToLaunchResult(input) {
                         asyncDir: input.result.details.asyncDir,
                         mode: input.result.details.mode,
                         state: status.state,
+                        // A run that finished before this launch result was attached keeps its acceptance in the status steps.
+                        ...(Array.isArray(status.steps) ? { results: status.steps.map((step) => ({ acceptance: step?.acceptance })) } : {}),
                         ...(firstText(input.result) ? { summary: firstText(input.result) } : {}),
                     }) ?? mission;
                 }
@@ -237,9 +263,12 @@ function parsePersistedBinding(value, source) {
         throw new Error(`${source}.writeGlobalIndex must be boolean`);
     if (input.retainTerminal !== undefined && (!Number.isInteger(input.retainTerminal) || input.retainTerminal < 1))
         throw new Error(`${source}.retainTerminal must be a positive integer`);
+    if (input.autoCreated !== undefined && typeof input.autoCreated !== "boolean")
+        throw new Error(`${source}.autoCreated must be boolean`);
     return {
         missionId: validateMissionId(input.missionId, `${source}.missionId`),
-        autoCreated: false,
+        // Bindings saved before this field existed belong to runs that completed their mission without an acceptance check.
+        autoCreated: input.autoCreated !== false,
         location: {
             projectRoot: input.projectRoot,
             missionDir: input.missionDir,
@@ -339,8 +368,9 @@ export function syncMissionFromAsyncCompletion(value) {
                 ? "stopped"
                 : "failed";
     const workflowChildTerminal = !["running", "queued", "active", "paused"].includes(workflowChildStatus);
+    const acceptanceStatus = missionAcceptanceStatus(event.results);
     return updateMission(binding.location, binding.missionId, {
-        status: missionStatusForRun(current, runId, runStatus),
+        status: missionStatusForRun(current, runId, runStatus, acceptanceStatus, binding.autoCreated),
         addRuns: [{ runId, mode: typeof event.mode === "string" && ["single", "parallel", "chain", "workflow"].includes(event.mode) ? event.mode : "external", asyncDir: event.asyncDir, status: runStatus, completedAt, ...(usage && usage.tokens > 0 ? { usage } : {}) }],
         addArtifacts: artifacts,
         ...(workflowRunId && workflowKey ? { upsertWorkflowChildren: [{
@@ -350,6 +380,7 @@ export function syncMissionFromAsyncCompletion(value) {
                     status: workflowChildStatus,
                     artifactPaths: artifacts.map((artifact) => artifact.path),
                     ...(workflowChildTerminal ? { completedAt } : {}),
+                    ...(acceptanceStatus ? { acceptanceStatus } : {}),
                     heartbeat: { status: workflowChildStatus, ...(summary ? { message: summary } : {}) },
                 }] } : {}),
         ...(summary ? { summary } : {}),

package/src/missions/store.js

@@ -133,6 +133,7 @@ function parseWorkflowChild(value, label) {
         ...(optionalString(input.phase, `${label}.phase`) ? { phase: input.phase } : {}),
         ...(input.completedAt !== undefined ? { completedAt: timestamp(input.completedAt, `${label}.completedAt`) } : {}),
         ...(optionalString(input.sessionPath, `${label}.sessionPath`) ? { sessionPath: input.sessionPath } : {}),
+        ...(optionalString(input.acceptanceStatus, `${label}.acceptanceStatus`) ? { acceptanceStatus: input.acceptanceStatus } : {}),
         ...(heartbeat ? { heartbeat: {
                 updatedAt: timestamp(heartbeat.updatedAt, `${label}.heartbeat.updatedAt`),
                 ...(optionalString(heartbeat.status, `${label}.heartbeat.status`) ? { status: heartbeat.status } : {}),