@henryqw/pi-subagent 25.1.0 → 25.1.1

package/dist/direct-herdr.js

@@ -243,11 +243,6 @@ export function createDirectHerdr(pi, cwd, idleMs) {
                             const waited = await herdr.exec(args, options(signal));
                             if (waited.code !== 0 || waited.killed) {
                                 if (!waited.killed && hasHerdrErrorCode(waited, "timeout")) {
-                                    if (current === "idle") {
-                                        const answer = await maybeAnswer();
-                                        if (answer !== undefined)
-                                            return answer;
-                                    }
                                     continue;
                                 }
                                 throw new Error(herdrCommandFailure(args, waited));

package/dist/ephemeral.js

@@ -429,9 +429,8 @@ async function runPi(prepared, input, budget, invocation) {
         let spawnError;
         let protocolError;
         let aborted = false;
-        let turnLimited = false;
+        let limit;
         let tokenBudget = "within";
-        const tokenLimited = () => tokenBudget === "limited";
         let startedTurns = 0;
         let lastEventAt = startedAt;
         let deadline = Math.min(startedAt + timeoutPolicy.idleMs, maxDeadline ?? startedAt + timeoutPolicy.idleMs);
@@ -514,15 +513,12 @@ async function runPi(prepared, input, budget, invocation) {
                     : `Subagent timed out after ${formatDuration(timeoutPolicy.idleMs)} without a recognized Pi event.`;
                 reject(new EphemeralSubagentError("timeout", message, new Error(message), accumulatedUsage()));
             }
-            else if (turnLimited) {
-                const summary = `Subagent reached its maximum turn limit of ${budget.maxTurns}.`;
+            else if (limit) {
+                const summary = limit === "turn_limit"
+                    ? `Subagent reached its maximum turn limit of ${budget.maxTurns}.`
+                    : `Subagent reached its maximum token limit of ${budget.maxTokens}.`;
                 const message = output ? capEphemeralSubagentOutput(`${summary}\n\nLast assistant output:\n${output}`) : summary;
-                reject(new EphemeralSubagentError("turn_limit", message, new Error(message), accumulatedUsage(), output));
-            }
-            else if (tokenLimited()) {
-                const summary = `Subagent reached its maximum token limit of ${budget.maxTokens}.`;
-                const message = output ? capEphemeralSubagentOutput(`${summary}\n\nLast assistant output:\n${output}`) : summary;
-                reject(new EphemeralSubagentError("token_limit", message, new Error(message), accumulatedUsage(), output));
+                reject(new EphemeralSubagentError(limit, message, new Error(message), accumulatedUsage(), output));
             }
             else if (protocolError) {
                 reject(new EphemeralSubagentError("protocol", protocolError.message, protocolError, accumulatedUsage()));
@@ -585,7 +581,7 @@ async function runPi(prepared, input, budget, invocation) {
             deadlineTimer.unref();
         };
         const observeEvent = () => {
-            if (callbackFailure || aborted || timedOutAfterMs !== undefined || turnLimited || tokenLimited() || childExited)
+            if (callbackFailure || aborted || timedOutAfterMs !== undefined || limit || childExited)
                 return;
             const now = Date.now();
             if (now >= deadline) {
@@ -609,17 +605,15 @@ async function runPi(prepared, input, budget, invocation) {
                 case "final_turn":
                     if (event === "turn_start") {
                         if (!callbackFailure && !aborted && timedOutAfterMs === undefined)
-                            tokenBudget = "limited";
+                            limit = "token_limit";
                         stop(true);
                         return true;
                     }
                     return false;
-                case "limited":
-                    return true;
             }
         };
         const processLine = (line) => {
-            if (turnLimited || tokenLimited() || !line.trim())
+            if (limit || !line.trim())
                 return;
             let event;
             try {
@@ -637,7 +631,7 @@ async function runPi(prepared, input, budget, invocation) {
             if (record.type === "turn_start") {
                 if (++startedTurns > budget.maxTurns) {
                     if (!callbackFailure && !aborted && timedOutAfterMs === undefined)
-                        turnLimited = true;
+                        limit = "turn_limit";
                     stop(true);
                     return;
                 }
@@ -775,7 +769,7 @@ async function runPi(prepared, input, budget, invocation) {
         };
         onStdoutData = (data) => {
             armPostExitIdleDeadline();
-            if (callbackFailure || protocolError || turnLimited || tokenLimited())
+            if (callbackFailure || protocolError || limit)
                 return;
             let offset = 0;
             while (offset < data.length) {
@@ -816,7 +810,7 @@ async function runPi(prepared, input, budget, invocation) {
                         invokeCallback("onActivity", input.onActivity, activity);
                     }
                 }
-                if (callbackFailure || turnLimited || tokenLimited())
+                if (callbackFailure || limit)
                     return;
                 lineParts = [];
                 lineBytes = 0;
@@ -856,13 +850,13 @@ async function runPi(prepared, input, budget, invocation) {
             killTimer.unref();
         }
         const abort = () => {
-            if (timedOutAfterMs !== undefined || turnLimited || tokenLimited() || childExited)
+            if (timedOutAfterMs !== undefined || limit || childExited)
                 return;
             aborted = true;
             stop();
         };
         function timeout(afterMs, reason) {
-            if (timedOutAfterMs !== undefined || turnLimited || tokenLimited() || childExited)
+            if (timedOutAfterMs !== undefined || limit || childExited)
                 return;
             if (reason === "maximum") {
                 if (!aborted) {

package/dist/git-process.js

@@ -1,17 +1,10 @@
-import { spawnBounded } from "@henryqw/pi-process";
+import { runProcess } from "./process.js";
 const GIT_TIMEOUT_MS = 30_000;
-const GIT_OUTPUT_LIMIT_BYTES = 1 * 1024 * 1024;
 const GIT_DIAGNOSTIC_LIMIT = 200;
 /** Run one ordinary Git command with bounded output; transport failures never throw. */
 export const runGit = async (args, cwd, signal) => {
     try {
-        const result = await spawnBounded("git", ["--no-pager", ...args], {
-            cwd,
-            signal,
-            timeoutMs: GIT_TIMEOUT_MS,
-            stdoutLimitBytes: GIT_OUTPUT_LIMIT_BYTES,
-            stderrLimitBytes: GIT_OUTPUT_LIMIT_BYTES,
-        });
+        const result = await runProcess("git", ["--no-pager", ...args], { cwd, signal, timeoutMs: GIT_TIMEOUT_MS });
         if (result.killed) {
             return {
                 code: -1,

package/dist/index.js

@@ -374,10 +374,9 @@ export async function resolveConfiguredRoleLaunch(pi, ctx, input) {
     const roleName = parseRoleName(input.role);
     if (input.modelClass === undefined)
         throw new Error("Configured Role launch requires an explicit modelClass.");
-    const matches = loadRoles().filter((role) => role.name === roleName);
-    if (matches.length !== 1)
+    const role = loadRoles().find((role) => role.name === roleName);
+    if (!role)
         throw new Error(`Required configured Role ${roleName} is missing or ambiguous.`);
-    const role = matches[0];
     if (role.mcps?.length)
         loadRoleMcpConfig(getAgentDir(), role.mcps, { codemode: roleActivatesCodemode(role.tools) });
     const resources = await resolveRolePackageResources(role, ctx);

package/dist/launch-runtime.js

@@ -125,11 +125,7 @@ export class RoleLaunchRuntime {
     }
     async prepareLaunch(role, modelClass, context) {
         abortIfNeeded(context.signal);
-        const input = { role, modelClass, task: ISOLATED_MODEL_TASK };
-        const prepared = await resolveConfiguredRoleLaunch(this.options.pi, this.options.context(), input);
-        if (prepared.missingSkills.length) {
-            throw new Error(`Role ${role} requires missing Skills: ${prepared.missingSkills.join(", ")}.`);
-        }
+        const prepared = await resolveConfiguredRoleLaunch(this.options.pi, this.options.context(), { role, modelClass });
         return Object.freeze({
             launch: Object.freeze({
                 role: prepared.role,

package/dist/process.d.ts

@@ -1,6 +1,6 @@
 type ProcessOptions = {
     cwd: string;
-    signal: AbortSignal;
+    signal?: AbortSignal;
     timeoutMs?: number;
     stdin?: string;
 };

package/dist/runner.js

@@ -131,12 +131,12 @@ class FollowupControl {
         if (this.queue.length >= MAX_QUEUED_FOLLOWUPS)
             throw new Error(`A task may queue at most ${MAX_QUEUED_FOLLOWUPS} follow-ups.`);
         this.validateFollowup(instruction);
-        this.queue.push({ kind: "followup", instruction });
+        this.queue.push(instruction);
     }
     drainPending() {
         if (this.sealed)
             throw new Error("This task candidate is already sealed for integration.");
-        return this.queue.splice(0).map(({ instruction }) => instruction);
+        return this.queue.splice(0);
     }
     takeQueuedFollowup() {
         if (this.sealed)
@@ -578,7 +578,7 @@ export class IsolatedRunner {
     }
     drainFollowups(root, requestId, taskId) {
         const active = this.activeControl(realpathSync.native(root), requestId, taskId);
-        if (!active || !this.canFollowup(root, requestId, taskId)) {
+        if (!active || active.task.status !== "working" || active.control.isSealed) {
             throw new Error(`Task ${taskId} is not an active unsealed changeset.`);
         }
         return active.control.drainPending();
@@ -589,7 +589,7 @@ export class IsolatedRunner {
             throw new Error("Follow-up instruction must be non-empty exact text of at most 32000 characters.");
         }
         const active = this.activeControl(realpathSync.native(root), requestId, taskId);
-        if (!active || !this.canFollowup(realpathSync.native(root), requestId, taskId)) {
+        if (!active || active.task.status !== "working" || active.control.isSealed) {
             throw new Error(`Task ${taskId} is not an active unsealed changeset.`);
         }
         if (latestAttempt(active.task).prompts.length + active.control.pendingFollowups >= MAX_WORKER_PROMPTS) {
@@ -1093,7 +1093,8 @@ export class IsolatedRunner {
         return await this.withProductiveRun(root, async (lifecycle) => {
             const handle = await this.store.withLock(root, async () => await this.store.load(root, action.id), { productiveRunLease: lifecycle.lease });
             const state = handle.state;
-            const request = parseExecuteRequest(state.request);
+            // Loading state has already normalized optional request fields, including finalChecks.
+            const request = state.request;
             const generation = state.integration.generations.at(-1);
             if (action.action === "release") {
                 const scope = new ProductiveScope(outerSignal);
@@ -2300,7 +2301,7 @@ export class IsolatedRunner {
                     const queuedFollowup = control.takeQueuedFollowupOrSeal();
                     if (queuedFollowup) {
                         kind = "followup";
-                        instruction = queuedFollowup.instruction;
+                        instruction = queuedFollowup;
                         task.status = "working";
                         continue;
                     }
@@ -2336,7 +2337,7 @@ export class IsolatedRunner {
             const queuedFollowup = control.takeQueuedFollowup();
             if (queuedFollowup) {
                 kind = "followup";
-                instruction = queuedFollowup.instruction;
+                instruction = queuedFollowup;
                 task.status = "working";
                 continue;
             }

package/dist/store.js

@@ -61,7 +61,7 @@ async function canonicalPlannedPath(path) {
     }
 }
 function serialize(state, maxBytes = STATE_MAX_BYTES) {
-    const validated = parseRunState(structuredClone(state));
+    const validated = parseRunState(state);
     const contents = `${JSON.stringify(validated, null, 2)}\n`;
     if (Buffer.byteLength(contents, "utf8") > maxBytes) {
         throw new Error(`pi-subagent state exceeds ${maxBytes} bytes.`);

package/extensions/isolated.ts

@@ -23,12 +23,12 @@ import {
 	IntegrationActionParameters,
 	parseIntegrationAction,
 	parseStageRequest,
-	parseExecuteRequest,
 	parseIdOnly,
 	parseResumeRequest,
 	sameIdentity,
 	StatusOutputSchema,
 	type CheckBatchEvidence,
+	type ExecuteRequest,
 	type ModelClass,
 	type ReviewEvidence,
 	type RunState,
@@ -412,7 +412,7 @@ function toolResult(response: RunResponse, ctx: ExtensionContext, rowsByRequest:
 }
 
 export interface IsolatedSurface {
-	execute(params: unknown, signal: AbortSignal | undefined, ctx: ExtensionContext): Promise<ReturnType<typeof toolResult>>;
+	execute(request: ExecuteRequest, signal: AbortSignal | undefined, ctx: ExtensionContext): Promise<ReturnType<typeof toolResult>>;
 	inventory(cwd: string, current?: () => boolean): Promise<IsolatedInventory>;
 	recover(cwd: string): Promise<string>;
 	inspect(root: string, requestId: string): Promise<readonly string[]>;
@@ -767,10 +767,9 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 			requireCurrent(current);
 			return getComponents().runner.drainFollowups(root, requestId, taskId);
 		},
-		async execute(params, signal, ctx) {
+		async execute(request, signal, ctx) {
 			latestCtx = ctx;
 			latestContext();
-			const request = parseExecuteRequest(params);
 			const root = await lookupRoot(ctx.cwd, signal);
 			return await startInSession(request.id, root, signal, ctx,
 				(state) => state.status === "pending" && state.createdAt === state.updatedAt

package/extensions/workflow.ts

@@ -42,8 +42,7 @@ export const DirectWorkflowSchema = Type.Object({
 	chain: Type.Optional(Type.Array(DelegationSchema, { minItems: 1, maxItems: MAX_WORKFLOW_ENTRIES })),
 }, { additionalProperties: false, description: "Direct mode: exactly one compact single, tasks, or chain workflow" });
 
-export const DelegateTaskSchema = Type.Union([DirectWorkflowSchema, ExecuteRequestSchema]);
-// Keep the strict mode union for parsing; expose a plain object root to tool providers.
+// Parse each mode with its strict schema; expose a plain object root to tool providers.
 export const DelegateTaskParameters = Type.Object({
 	...DirectWorkflowSchema.properties,
 	mode: Type.Union([DirectWorkflowSchema.properties.mode, ExecuteRequestSchema.properties.mode]),
@@ -56,7 +55,6 @@ export const DelegateTaskParameters = Type.Object({
 	finalChecks: ExecuteRequestSchema.properties.finalChecks,
 	finalJudgment: ExecuteRequestSchema.properties.finalJudgment,
 }, { additionalProperties: false });
-export const WorkflowSchema = DirectWorkflowSchema;
 
 export type Delegation = Static<typeof DelegationSchema> & { kind: "text" };
 export type WorkflowMode = "single" | "parallel" | "chain";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "25.1.0",
+  "version": "25.1.1",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",