@henryqw/pi-subagent 3.1.0 → 4.0.1

package/dist/ephemeral.d.ts

@@ -47,4 +47,6 @@ export interface EphemeralSubagentExecutor {
  */
 export declare function createEphemeralSubagentExecutor(options: EphemeralSubagentExecutorOptions): EphemeralSubagentExecutor;
 export declare function capEphemeralSubagentOutput(text: string): string;
+export declare function addUsage(left: Usage | undefined, right: Usage | undefined): Usage | undefined;
+export declare function formatDuration(milliseconds: number): string;
 export {};

package/dist/ephemeral.js

@@ -294,7 +294,7 @@ function usageFrom(value) {
 function sumOptional(left, right) {
     return left === undefined && right === undefined ? undefined : (left ?? 0) + (right ?? 0);
 }
-function addUsage(left, right) {
+export function addUsage(left, right) {
     if (!left)
         return right;
     if (!right)
@@ -318,7 +318,7 @@ function addUsage(left, right) {
         },
     };
 }
-function formatDuration(milliseconds) {
+export function formatDuration(milliseconds) {
     const seconds = Math.max(0, Math.floor(milliseconds / 1_000));
     const hours = Math.floor(seconds / 3_600);
     const minutes = Math.floor(seconds % 3_600 / 60);

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type HerdrExecutor } from "@henryqw/pi-herdr";
 import { type AvailableModel, type ProfileName, type ResolvedTaskRoute, type ThinkingLevel } from "@henryqw/pi-task-models";
-export { capEphemeralSubagentOutput, createEphemeralSubagentExecutor, EphemeralSubagentError, type EphemeralSubagentErrorCode, type EphemeralSubagentExecutor, type EphemeralSubagentExecutorOptions, type EphemeralSubagentResult, type EphemeralSubagentRunInput, type EphemeralSubagentTimeout, } from "./ephemeral.ts";
+export { addUsage, capEphemeralSubagentOutput, createEphemeralSubagentExecutor, EphemeralSubagentError, formatDuration, type EphemeralSubagentErrorCode, type EphemeralSubagentExecutor, type EphemeralSubagentExecutorOptions, type EphemeralSubagentResult, type EphemeralSubagentRunInput, type EphemeralSubagentTimeout, } from "./ephemeral.ts";
 export { createChildWorktree, finalizeChildWorktree, worktreeContextNote, type WorktreeInfo, type WorktreePayload, } from "./worktree.ts";
+export declare const ROLE_TOOL_POLICY_FLAG = "pi-subagent-role-tools";
+export declare const CHILD_EXCLUDED_TOOLS = "delegate_task,ask_question,auto_dag_execute,auto_dag_acknowledge";
 export interface Role {
     name: string;
     description: string;
@@ -36,7 +38,6 @@ export interface ResolvedRoleSkills {
     paths: string[];
     missing: string[];
 }
-export declare const isProfileName: (value: unknown) => value is ProfileName;
 export declare function loadRoles(agentDir?: string): Role[];
 export declare function resolveTaskRoute(ctx: ExtensionContext, profileName: ProfileName, agentDir?: string, thinking?: ThinkingLevel): ResolvedTaskRoute;
 export declare function resolveRoleSkills(pi: Pick<ExtensionAPI, "getCommands">, role: Role): ResolvedRoleSkills;
@@ -58,7 +59,6 @@ export interface ManagedSubagentTab {
     tabId: string;
     paneId: string;
 }
-export declare function launchEnvironmentArgs(launch: PiLaunch): string[];
 export declare function managedSubagentName(workspaceId: string, ...identity: string[]): string;
 export declare function managedSubagentWorkspaceId(cwd: string, mainPane: string, options: ManagedSubagentHostOptions): Promise<string>;
 /** Returns pane ID to Herdr status for agents owned by this workspace. */

package/dist/index.js

@@ -3,16 +3,15 @@ import { readFileSync, readdirSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { createHerdrClient, herdrCommandFailure, hasHerdrErrorCode } from "@henryqw/pi-herdr";
-import { modelReference, orderedProfileRoutes, PROFILE_NAMES, readTaskModelsConfig, resolveConfiguredTaskRoute, resolveTaskModelRoute, } from "@henryqw/pi-task-models";
-export { capEphemeralSubagentOutput, createEphemeralSubagentExecutor, EphemeralSubagentError, } from "./ephemeral.js";
+import { createHerdrClient, herdrCommandFailure, hasHerdrErrorCode, startPiAgent } from "@henryqw/pi-herdr";
+import { modelReference, orderedProfileRoutes, readTaskModelsConfig, resolveConfiguredTaskRoute, resolveTaskModelRoute, } from "@henryqw/pi-task-models";
+export { addUsage, capEphemeralSubagentOutput, createEphemeralSubagentExecutor, EphemeralSubagentError, formatDuration, } from "./ephemeral.js";
 export { createChildWorktree, finalizeChildWorktree, worktreeContextNote, } from "./worktree.js";
 const CODEX_ALIAS = /^openai-codex-(?:[2-9]|[1-9]\d+)$/;
 const MULTI_CODEX_EXTENSION = fileURLToPath(import.meta.resolve("@henryqw/pi-multi-codex/extensions/multi-codex.ts"));
 const ROLE_TOOLS_EXTENSION = fileURLToPath(new URL("../extensions/role-tools.ts", import.meta.url));
-const ROLE_TOOL_POLICY_FLAG = "pi-subagent-role-tools";
-const CHILD_EXCLUDED_TOOLS = "delegate_task,ask_question,auto_dag_execute,auto_dag_acknowledge";
-export const isProfileName = (value) => typeof value === "string" && PROFILE_NAMES.includes(value);
+export const ROLE_TOOL_POLICY_FLAG = "pi-subagent-role-tools";
+export const CHILD_EXCLUDED_TOOLS = "delegate_task,ask_question,auto_dag_execute,auto_dag_acknowledge";
 const cleanText = (value, field, source) => {
     if (typeof value !== "string" || !value.trim() || value.includes("\0")) {
         throw new Error(`${source}: ${field} must be non-empty text.`);
@@ -176,7 +175,7 @@ export function resolveRoleLaunch(pi, ctx, input) {
         route: resolveConfiguredTaskRoute(ctx, taskId, input.agentDir),
     });
 }
-export function launchEnvironmentArgs(launch) {
+function launchEnvironmentArgs(launch) {
     return Object.entries(launch.env).flatMap(([key, value]) => {
         if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || typeof value !== "string" || value.includes("\0")) {
             throw new Error(`Invalid launch environment: ${key}`);
@@ -310,27 +309,27 @@ export async function startManagedSubagent(host, agent, pane, launch, options, h
         return "existing";
     }
     await hooks.beforeStart?.();
-    const arguments_ = ["agent", "start", name, "--kind", "pi", "--pane", paneId, "--", ...launch.args];
     const herdr = createHerdrClient(options.execute);
-    for (let attempt = 1; attempt <= 5; attempt += 1) {
-        const result = await herdr.exec(arguments_, { cwd: host.cwd });
-        if (result.code === 0 && !result.killed) {
-            await hooks.onStarted?.();
-            return "started";
-        }
-        if (hasHerdrErrorCode(result, "agent_name_taken")) {
-            const raced = await getManagedSubagent(host, name, options);
-            if (!raced)
-                throw new Error(`Herdr agent ${name} reported agent_name_taken but could not be found; refusing to start a duplicate`);
-            assertAgentPane(name, paneId, raced);
-            return "existing";
-        }
-        if (!hasHerdrErrorCode(result, "agent_pane_busy") || attempt === 5) {
-            throw new Error(herdrCommandFailure(arguments_, result));
-        }
-        await (options.delay ?? delay)(250);
+    const startArgs = ["agent", "start", name, "--kind", "pi", "--pane", paneId, "--", ...launch.args];
+    const result = await startPiAgent(herdr, {
+        name,
+        pane: paneId,
+        args: launch.args,
+        options: { cwd: host.cwd },
+        delay: options.delay,
+    });
+    if (result.code === 0 && !result.killed) {
+        await hooks.onStarted?.();
+        return "started";
     }
-    throw new Error(`Herdr agent ${name} could not be started`);
+    if (hasHerdrErrorCode(result, "agent_name_taken")) {
+        const raced = await getManagedSubagent(host, name, options);
+        if (!raced)
+            throw new Error(`Herdr agent ${name} reported agent_name_taken but could not be found; refusing to start a duplicate`);
+        assertAgentPane(name, paneId, raced);
+        return "existing";
+    }
+    throw new Error(herdrCommandFailure(startArgs, result));
 }
 export async function promptManagedSubagent(host, agent, prompt, options) {
     assertAgentName(agent);
@@ -404,6 +403,3 @@ async function confirmsTabAbsent(host, tabId, options) {
         return false;
     }
 }
-async function delay(milliseconds) {
-    await new Promise((done) => { setTimeout(done, milliseconds); });
-}

package/extensions/config.ts

@@ -27,10 +27,7 @@ const positive = (value: unknown): value is number =>
 // every child immediately instead of applying the configured deadline.
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 export const DEFAULT_TIMEOUT_CONFIG = { idleMinutes: 10, maxMinutes: 30 } as const;
-const TIMEOUT_FIELDS: Array<[keyof SubagentTimeoutConfig, string]> = [
-	["idleMinutes", "minutes"],
-	["maxMinutes", "minutes"],
-];
+const TIMEOUT_FIELDS = ["idleMinutes", "maxMinutes"] as const;
 
 /**
  * All pi-subagent config lives in its existing extension-named directory;
@@ -88,20 +85,20 @@ export function readSubagentConfig(agentDir = getAgentDir()): LoadedSubagentConf
 		} else {
 			const timeoutRecord = record.timeout as Record<string, unknown>;
 			const timeout: SubagentTimeoutConfig = {};
-			for (const [key, unit] of TIMEOUT_FIELDS) {
+			for (const key of TIMEOUT_FIELDS) {
 				const value = timeoutRecord[key];
 				if (value === undefined) continue;
 				if (!positive(value)) {
-					problems.push(`timeout.${key} must be a positive number of ${unit}, got ${JSON.stringify(value)}`);
+					problems.push(`timeout.${key} must be a positive number of minutes, got ${JSON.stringify(value)}`);
 				} else if (value * 60_000 > MAX_TIMER_DELAY_MS) {
-					problems.push(`timeout.${key} exceeds the maximum supported delay of ${MAX_TIMER_DELAY_MS} ms, got ${JSON.stringify(value)} ${unit}`);
+					problems.push(`timeout.${key} exceeds the maximum supported delay of ${MAX_TIMER_DELAY_MS} ms, got ${JSON.stringify(value)} minutes`);
 				} else {
 					timeout[key] = value;
 				}
 			}
 			for (const key of Object.keys(timeoutRecord)) {
-				if (!TIMEOUT_FIELDS.some(([known]) => known === key)) {
-					problems.push(`unknown timeout.${key}; expected ${TIMEOUT_FIELDS.map(([known]) => known).join(", ")}`);
+				if (!TIMEOUT_FIELDS.includes(key as keyof SubagentTimeoutConfig)) {
+					problems.push(`unknown timeout.${key}; expected ${TIMEOUT_FIELDS.join(", ")}`);
 				}
 			}
 			if (Object.keys(timeout).length) config.timeout = timeout;

package/extensions/result-transport.ts

@@ -1,5 +1,6 @@
 import type { Usage } from "@earendil-works/pi-ai";
 import {
+	addUsage,
 	capEphemeralSubagentOutput,
 	type EphemeralSubagentResult,
 	type WorktreePayload,
@@ -63,31 +64,6 @@ function splitEvidence(text: string): [string, string] {
 	return [preview, text.slice(preview.length)];
 }
 
-function sumOptional(left: number | undefined, right: number | undefined): number | undefined {
-	return left === undefined && right === undefined ? undefined : (left ?? 0) + (right ?? 0);
-}
-
-function addUsage(left: Usage | undefined, right: Usage): Usage {
-	const cacheWrite1h = sumOptional(left?.cacheWrite1h, right.cacheWrite1h);
-	const reasoning = sumOptional(left?.reasoning, right.reasoning);
-	return {
-		input: (left?.input ?? 0) + right.input,
-		output: (left?.output ?? 0) + right.output,
-		cacheRead: (left?.cacheRead ?? 0) + right.cacheRead,
-		cacheWrite: (left?.cacheWrite ?? 0) + right.cacheWrite,
-		...(cacheWrite1h === undefined ? {} : { cacheWrite1h }),
-		...(reasoning === undefined ? {} : { reasoning }),
-		totalTokens: (left?.totalTokens ?? 0) + right.totalTokens,
-		cost: {
-			input: (left?.cost.input ?? 0) + right.cost.input,
-			output: (left?.cost.output ?? 0) + right.cost.output,
-			cacheRead: (left?.cost.cacheRead ?? 0) + right.cost.cacheRead,
-			cacheWrite: (left?.cost.cacheWrite ?? 0) + right.cost.cacheWrite,
-			total: (left?.cost.total ?? 0) + right.cost.total,
-		},
-	};
-}
-
 function label(kind: TransportKind, failed: boolean): string {
 	if (kind === "update") return "Workflow update.";
 	if (kind === "background") return `Background workflow ${failed ? "failed" : "succeeded"}.`;

package/extensions/role-tools.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { CHILD_EXCLUDED_TOOLS, ROLE_TOOL_POLICY_FLAG } from "@henryqw/pi-subagent";
 
-export const ROLE_TOOL_POLICY_FLAG = "pi-subagent-role-tools";
-const CHILD_EXCLUDED_TOOLS = new Set(["delegate_task", "ask_question", "auto_dag_execute", "auto_dag_acknowledge"]);
+const childExcludedTools = new Set(CHILD_EXCLUDED_TOOLS.split(","));
 
 function configuredTools(value: unknown): string[] | undefined {
 	if (value === undefined) return;
@@ -29,6 +29,6 @@ export default function roleTools(pi: ExtensionAPI): void {
 		const extensionTools = pi.getAllTools()
 			.filter((tool) => !["builtin", "sdk", "inline"].includes(tool.sourceInfo.source))
 			.map((tool) => tool.name);
-		pi.setActiveTools([...new Set([...selected, ...extensionTools])].filter((name) => !CHILD_EXCLUDED_TOOLS.has(name)));
+		pi.setActiveTools([...new Set([...selected, ...extensionTools])].filter((name) => !childExcludedTools.has(name)));
 	});
 }

package/extensions/subagent.ts

@@ -17,6 +17,7 @@ import {
 	createRoleLaunch,
 	EphemeralSubagentError,
 	finalizeChildWorktree,
+	formatDuration,
 	loadRoles,
 	resolveTaskRoute,
 	worktreeContextNote,
@@ -45,8 +46,6 @@ import {
 	type WorkflowEntry,
 } from "./workflow.ts";
 
-export { capOutput };
-
 const SUBAGENT_TASK = "pi-subagent/delegateTask";
 const WIDGET_KEY = "subagent-status";
 const WIDGET_INTERVAL_MS = 80;
@@ -89,13 +88,6 @@ function formatTokens(tokens: number): string {
 	return `${(tokens / 1_000_000).toFixed(1)}M`;
 }
 
-function formatElapsed(startedAt: number, finishedAt = Date.now()): string {
-	const seconds = Math.max(0, Math.floor((finishedAt - startedAt) / 1_000));
-	const hours = Math.floor(seconds / 3_600);
-	const minutes = Math.floor(seconds % 3_600 / 60);
-	return hours ? `${hours}h ${minutes}m` : minutes ? `${minutes}m ${seconds % 60}s` : `${seconds}s`;
-}
-
 function statusGlyph(status: WidgetStatus, spinnerIndex: number, theme: Theme): string {
 	switch (status) {
 		case "working": return theme.fg("accent", SPINNER_FRAMES[spinnerIndex % SPINNER_FRAMES.length]!);
@@ -123,7 +115,7 @@ function renderWidgetRows(
 	const visible = items.slice(0, MAX_WIDGET_ROWS);
 	if (!visible.length) return [];
 	const tokens = visible.map((item) => formatTokens(item.tokens));
-	const elapsed = visible.map((item) => formatElapsed(item.startedAt, item.finishedAt ?? now));
+	const elapsed = visible.map((item) => formatDuration((item.finishedAt ?? now) - item.startedAt));
 	const tokenWidth = Math.max(...tokens.map(visibleWidth));
 	const elapsedWidth = Math.max(...elapsed.map(visibleWidth));
 	const fixedWidth = 1 + 8 + tokenWidth + elapsedWidth;

package/extensions/workflow.ts

@@ -1,6 +1,7 @@
 import { StringEnum } from "@earendil-works/pi-ai";
-import { PROFILE_NAMES, THINKING_LEVELS, type ProfileName, type ThinkingLevel } from "@henryqw/pi-task-models";
+import { PROFILE_NAMES, THINKING_LEVELS } from "@henryqw/pi-task-models";
 import { Type, type Static } from "typebox";
+import { Check } from "typebox/value";
 
 export const MAX_WORKFLOW_ENTRIES = 8;
 
@@ -47,78 +48,61 @@ export type ParsedWorkflow =
 	| { mode: "parallel"; background: boolean; delegations: Delegation[] }
 	| { mode: "chain"; background: boolean; delegations: Delegation[] };
 
-const DELEGATION_KEYS = ["role", "task", "model", "modelClass", "thinking"] as const;
-const TOP_LEVEL_KEYS = [...DELEGATION_KEYS, "tasks", "chain", "background"] as const;
-
-function record(value: unknown, path: string): Record<string, unknown> {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${path} must be an object.`);
-	return value as Record<string, unknown>;
-}
-
-function rejectUnknown(value: Record<string, unknown>, allowed: readonly string[], path: string): void {
-	const unknown = Object.keys(value).find((key) => !allowed.includes(key));
-	if (unknown) throw new Error(`${path} contains unknown property ${JSON.stringify(unknown)}.`);
-}
+type WorkflowInput = Static<typeof WorkflowSchema>;
 
-function text(value: unknown, path: string): string {
-	if (typeof value !== "string" || !value.trim() || value.includes("\0")) {
-		throw new Error(`${path} must be non-empty text without NUL.`);
-	}
-	return value.trim();
-}
+const DELEGATION_KEYS = ["role", "task", "model", "modelClass", "thinking"] as const;
 
-function enumValue<T extends string>(value: unknown, values: readonly T[], path: string): T {
-	if (typeof value !== "string" || !values.includes(value as T)) {
-		throw new Error(`${path} must be one of: ${values.join(", ")}.`);
-	}
-	return value as T;
+function text(value: string, path: string): string {
+	const normalized = value.trim();
+	if (!normalized || value.includes("\0")) throw new Error(`${path} must be non-empty text without NUL.`);
+	return normalized;
 }
 
-function parseDelegation(value: unknown, path: string, extraKeys: readonly string[] = []): Delegation {
-	const input = record(value, path);
-	rejectUnknown(input, [...DELEGATION_KEYS, ...extraKeys], path);
-	if (!Object.hasOwn(input, "role") || !Object.hasOwn(input, "task")) {
-		throw new Error(`${path} requires both role and task.`);
-	}
-	const delegation: Delegation = {
-		role: text(input.role, `${path}.role`),
-		task: text(input.task, `${path}.task`),
+function normalizeDelegation(value: Delegation, path: string): Delegation {
+	return {
+		role: text(value.role, `${path}.role`),
+		task: text(value.task, `${path}.task`),
+		...(value.model === undefined ? {} : { model: text(value.model, `${path}.model`) }),
+		...(value.modelClass === undefined ? {} : { modelClass: value.modelClass }),
+		...(value.thinking === undefined ? {} : { thinking: value.thinking }),
 	};
-	if (Object.hasOwn(input, "model")) delegation.model = text(input.model, `${path}.model`);
-	if (Object.hasOwn(input, "modelClass")) {
-		delegation.modelClass = enumValue(input.modelClass, PROFILE_NAMES, `${path}.modelClass`) as ProfileName;
-	}
-	if (Object.hasOwn(input, "thinking")) {
-		delegation.thinking = enumValue(input.thinking, THINKING_LEVELS, `${path}.thinking`) as ThinkingLevel;
-	}
-	return delegation;
 }
 
-function parseDelegations(value: unknown, path: "tasks" | "chain"): Delegation[] {
-	if (!Array.isArray(value)) throw new Error(`${path} must be an array.`);
-	if (value.length < 1 || value.length > MAX_WORKFLOW_ENTRIES) {
-		throw new Error(`${path} must contain 1 to ${MAX_WORKFLOW_ENTRIES} delegations.`);
-	}
-	return value.map((delegation, index) => parseDelegation(delegation, `${path}[${index}]`));
+function hasDelegation(value: WorkflowInput): value is WorkflowInput & Delegation {
+	return Object.hasOwn(value, "role") && Object.hasOwn(value, "task");
 }
 
-export function parseWorkflow(value: unknown): ParsedWorkflow {
-	const input = record(value, "workflow");
-	rejectUnknown(input, TOP_LEVEL_KEYS, "workflow");
-	const background = Object.hasOwn(input, "background") ? input.background : false;
-	if (typeof background !== "boolean") throw new Error("workflow.background must be a boolean.");
-
-	const single = DELEGATION_KEYS.some((key) => Object.hasOwn(input, key));
-	const parallel = Object.hasOwn(input, "tasks");
-	const chain = Object.hasOwn(input, "chain");
+function workflowMode(value: unknown): WorkflowMode | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const single = DELEGATION_KEYS.some((key) => Object.hasOwn(value, key));
+	const parallel = Object.hasOwn(value, "tasks");
+	const chain = Object.hasOwn(value, "chain");
 	if (Number(single) + Number(parallel) + Number(chain) !== 1) {
 		throw new Error("workflow must select exactly one mode: role and task, tasks, or chain.");
 	}
-	if (single) {
-		return { mode: "single", background, delegations: [parseDelegation(input, "workflow", ["background"])] };
+	return single ? "single" : parallel ? "parallel" : "chain";
+}
+
+export function parseWorkflow(value: unknown): ParsedWorkflow {
+	const mode = workflowMode(value);
+	if (!Check(WorkflowSchema, value)) throw new Error("workflow must match the declared tool schema.");
+	if (!mode) throw new Error("workflow must select exactly one mode: role and task, tasks, or chain.");
+	const input = value;
+	const background = input.background ?? false;
+	if (mode === "single") {
+		if (!hasDelegation(input)) throw new Error("workflow requires both role and task.");
+		return { mode, background, delegations: [normalizeDelegation(input, "workflow")] };
 	}
-	if (parallel) return { mode: "parallel", background, delegations: parseDelegations(input.tasks, "tasks") };
-	return { mode: "chain", background, delegations: parseDelegations(input.chain, "chain") };
+	if (mode === "parallel") return {
+		mode,
+		background,
+		delegations: input.tasks!.map((delegation, index) => normalizeDelegation(delegation, `tasks[${index}]`)),
+	};
+	return {
+		mode,
+		background,
+		delegations: input.chain!.map((delegation, index) => normalizeDelegation(delegation, `chain[${index}]`)),
+	};
 }
 
 export type WorkflowEntry = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "3.1.0",
+  "version": "4.0.1",
   "description": "Delegate bounded single, parallel, or chained tasks to isolated Pi roles.",
   "keywords": [
     "pi-package",
@@ -31,6 +31,7 @@
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
+    "pretypecheck": "npm run build",
     "test": "npm run build && node --test test/*.test.ts",
     "typecheck": "tsc --noEmit --allowImportingTsExtensions --target ES2022 --module NodeNext --moduleResolution NodeNext --skipLibCheck src/*.ts extensions/*.ts test/*.test.ts",
     "prepack": "npm run build",
@@ -59,7 +60,7 @@
     ]
   },
   "dependencies": {
-    "@henryqw/pi-herdr": "^0.1.1",
+    "@henryqw/pi-herdr": "^0.4.0",
     "@henryqw/pi-multi-codex": "^0.3.8",
     "@henryqw/pi-task-models": "^1.0.0"
   }