@henryqw/pi-subagent 24.0.0 → 24.0.1

package/README.md

@@ -30,7 +30,7 @@ pi install npm:pi-mcp-adapter
 
 Ask Main to delegate a bounded task, such as “Have a scout trace sign-in without editing files.” Main uses `delegate_task`; you receive progress and a result or an actionable failure while Main remains available.
 
-Commands are for you; tools and the packaged skill are for Main. You do not need to call agent tools or manage candidate identities yourself.
+Commands are for you; tools and the packaged skill are for Main. You do not need to call agent tools or manage candidate identities yourself. Delegation and continuation tools use plain-object parameter schemas so providers that omit root-union tools can expose them; each mode and action still requires its exact arguments.
 
 | Surface | Type | Purpose |
 | --- | --- | --- |

package/dist/schema.d.ts

@@ -129,6 +129,11 @@ export declare const ResumeRequestSchema: Type.TUnion<[Type.TObject<{
     id: Type.TString;
     action: Type.TLiteral<"finalize">;
 }>]>;
+export declare const ResumeRequestParameters: Type.TObject<{
+    id: Type.TString;
+    action: Type.TUnion<[Type.TLiteral<"retry">, Type.TLiteral<"verify">, Type.TLiteral<"finalize">]>;
+    taskId: Type.TOptional<Type.TString>;
+}>;
 export type IdOnly = Static<typeof IdOnlySchema>;
 export type CheckCommand = Static<typeof CheckCommandSchema>;
 export type Judgment = Static<typeof JudgmentSchema>;
@@ -369,6 +374,31 @@ export declare const IntegrationActionSchema: Type.TUnion<[Type.TObject<{
     taskId: Type.TOptional<Type.TString>;
     attempt: Type.TOptional<Type.TInteger>;
 }>]>;
+export declare const IntegrationActionParameters: Type.TObject<{
+    id: Type.TString;
+    generation: Type.TInteger;
+    action: Type.TUnion<[Type.TLiteral<"refresh">, Type.TUnion<[Type.TLiteral<"advance">, Type.TLiteral<"validate">, Type.TLiteral<"correct">, Type.TLiteral<"promote">, Type.TLiteral<"reconcile">, Type.TLiteral<"cleanup">]>, Type.TLiteral<"release">]>;
+    expectedTip: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    expectedMain: Type.TOptional<Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>>;
+    newMain: Type.TOptional<Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>>;
+    taskId: Type.TOptional<Type.TString>;
+    attempt: Type.TOptional<Type.TInteger>;
+}>;
 export type IntegrationAction = Static<typeof IntegrationActionSchema>;
 export declare function parseIntegrationAction(value: unknown): IntegrationAction;
 export declare function parseStageRequest(value: unknown): StageRequest;

package/dist/schema.js

@@ -65,7 +65,17 @@ export const ResumeRequestSchema = Type.Union([
     Type.Object({ id: IdSchema, action: Type.Literal("retry"), taskId: IdSchema }, { additionalProperties: false }),
     Type.Object({ id: IdSchema, action: Type.Literal("verify"), taskId: IdSchema }, { additionalProperties: false }),
     Type.Object({ id: IdSchema, action: Type.Literal("finalize") }, { additionalProperties: false }),
-], { type: "object" });
+]);
+// Tool parameters need a plain object root; the action union remains the validation boundary.
+export const ResumeRequestParameters = Type.Object({
+    id: IdSchema,
+    action: Type.Union([
+        ResumeRequestSchema.anyOf[0].properties.action,
+        ResumeRequestSchema.anyOf[1].properties.action,
+        ResumeRequestSchema.anyOf[2].properties.action,
+    ]),
+    taskId: Type.Optional(IdSchema),
+}, { additionalProperties: false });
 const AllocationLifecycleFields = {
     generation: Type.Integer({ minimum: 1, maximum: 2 }),
     token: Type.String({ pattern: TOKEN_PATTERN }),
@@ -167,7 +177,21 @@ export const IntegrationActionSchema = Type.Union([
         taskId: Type.Optional(IdSchema),
         attempt: Type.Optional(Type.Integer({ minimum: 1, maximum: 2 })),
     }, { additionalProperties: false }),
-], { type: "object" });
+]);
+export const IntegrationActionParameters = Type.Object({
+    id: IntegrationActionSchema.anyOf[0].properties.id,
+    generation: IntegrationActionSchema.anyOf[0].properties.generation,
+    action: Type.Union([
+        IntegrationActionSchema.anyOf[0].properties.action,
+        IntegrationActionSchema.anyOf[1].properties.action,
+        IntegrationActionSchema.anyOf[2].properties.action,
+    ]),
+    expectedTip: IntegrationActionSchema.anyOf[0].properties.expectedTip,
+    expectedMain: Type.Optional(IntegrationActionSchema.anyOf[0].properties.expectedMain),
+    newMain: Type.Optional(IntegrationActionSchema.anyOf[0].properties.newMain),
+    taskId: IntegrationActionSchema.anyOf[2].properties.taskId,
+    attempt: IntegrationActionSchema.anyOf[2].properties.attempt,
+}, { additionalProperties: false });
 export function parseIntegrationAction(value) {
     if (!Check(IntegrationActionSchema, value))
         throw schemaValidationError("subagent_integrate requires an exact generation and tip", Errors(IntegrationActionSchema, value));

package/extensions/isolated.ts

@@ -17,9 +17,9 @@ import { RoleLaunchRuntime, type LaunchRuntimeOptions } from "../dist/launch-run
 import { IsolatedRunner, type OperationContext, type RunResponse } from "../dist/runner.js";
 import {
 	IdOnlySchema,
-	ResumeRequestSchema,
+	ResumeRequestParameters,
 	StageRequestSchema,
-	IntegrationActionSchema,
+	IntegrationActionParameters,
 	parseIntegrationAction,
 	parseStageRequest,
 	parseExecuteRequest,
@@ -614,7 +614,7 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 		name: "subagent_resume",
 		label: "Subagent resume",
 		description: "Resume one unfinished isolated request without resetting its recorded policy or correction count.",
-		parameters: ResumeRequestSchema,
+		parameters: ResumeRequestParameters,
 		prepareArguments: parseResumeRequest,
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			latestCtx = ctx;
@@ -641,7 +641,7 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 		name: "subagent_integrate",
 		label: "Subagent integrate",
 		description: "Main advances staged dependents, refreshes after clean Main drift, validates, corrects, promotes, reconciles an interrupted promotion, cleans up promoted resources, or explicitly releases rejected/superseded owned resources. Never replays an uncertain mutation.",
-		parameters: IntegrationActionSchema,
+		parameters: IntegrationActionParameters,
 		prepareArguments: parseIntegrationAction,
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			latestCtx = ctx;

package/extensions/subagent.ts

@@ -9,7 +9,7 @@ import { registerIsolatedExtension } from "./isolated.ts";
 import { registerSubagentCommand, type DirectTask } from "./subagent-command.ts";
 import { MODEL_CLASS_GUIDANCE } from "./model-class-policy.ts";
 import { ENTRY_STATUS_PRESENTATION, formatWorkflowResult, type BackgroundWorkflowTransportDetails, type WorkflowTransportEntry } from "./result-transport.ts";
-import { DelegateTaskSchema, identifyWorkflowEntries, parseDelegateTask, runForegroundWorkflow, type Delegation, type ParsedWorkflow, type WorkflowEntry } from "./workflow.ts";
+import { DelegateTaskParameters, identifyWorkflowEntries, parseDelegateTask, runForegroundWorkflow, type Delegation, type ParsedWorkflow, type WorkflowEntry } from "./workflow.ts";
 import { createDirectHerdr, type DirectHandle, type DirectTab } from "../dist/direct-herdr.js";
 import { materializeTransientLaunch } from "../dist/launch-runtime.js";
 const WIDGET_KEY = "subagent-status";
@@ -460,7 +460,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 			"Isolation uses typed tasks and dependencies. Keep tightly coupled changes with one owner; do not split by file count. Failures, ambiguity, limits, and conflicts retain work and never waive checks or identity guards.",
 			`For delegate_task, ${MODEL_CLASS_GUIDANCE} A direct model replaces only the selected route's model; its thinking level stays unchanged.`,
 		],
-		parameters: DelegateTaskSchema,
+		parameters: DelegateTaskParameters,
 		prepareArguments(args) {
 			try {
 				const parsed = parseDelegateTask(args);

package/extensions/workflow.ts

@@ -42,7 +42,21 @@ 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], { type: "object" });
+export const DelegateTaskSchema = Type.Union([DirectWorkflowSchema, ExecuteRequestSchema]);
+// Keep the strict mode union for parsing; expose a plain object root to tool providers.
+export const DelegateTaskParameters = Type.Object({
+	...DirectWorkflowSchema.properties,
+	mode: Type.Union([DirectWorkflowSchema.properties.mode, ExecuteRequestSchema.properties.mode]),
+	id: Type.Optional(ExecuteRequestSchema.properties.id),
+	goal: Type.Optional(ExecuteRequestSchema.properties.goal),
+	tasks: Type.Optional(Type.Union([
+		Type.Array(DelegationSchema, { minItems: 1, maxItems: MAX_WORKFLOW_ENTRIES }),
+		ExecuteRequestSchema.properties.tasks,
+	])),
+	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": "24.0.0",
+  "version": "24.0.1",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",