@henryqw/pi-task-models 2.0.0 → 3.0.1

package/CONTEXT.md

@@ -1,9 +1,13 @@
 # Pi Task Models
 
-Pi Task Models stores shared task profiles and task-to-profile assignments for HenryQW extensions; `pi-subagent/delegateTask` defaults to `fast`.
+Pi Task Models stores shared Task Profiles and explicit user overrides for consumer-owned Model Tasks. Consumers declare identity, intent, and default profiles; this package has no consumer catalog or package/source discovery.
 
 ## Language
 
+**Model Task**:
+A consumer-owned independently executed model operation. Exists only for independent model execution — not for work performed by the current session agent. Each consumer owns its Model Task ID, label, purpose, execution/prompt, and default Task Profile.
+_Avoid_: package-wide model setting, centrally owned consumer-task catalog, current-agent work
+
 **Task Profile**:
 Named shared route set (`fast`, `balanced`, `frontier`, or `fav`) with a required primary route and optional fallback route (`fav` has no fallback).
 _Avoid_: package-owned model picker, per-extension model catalog
@@ -12,6 +16,6 @@ _Avoid_: package-owned model picker, per-extension model catalog
 One model reference plus thinking level chosen from current Pi model scope. Empty scope means every available registry model; pinned scope thinking remains binding.
 _Avoid_: free-form provider path, copied model metadata
 
-**Active Task Package**:
-Installed HenryQW package discovered from Pi command/tool sourceInfo.
-_Avoid_: filesystem scan, settings.json scan
+**Task declaration discovery**:
+The single control plane requests active consumer declarations through an idempotent namespaced Pi event request/response handshake when `/task-models` opens. It shows each declaration's effective `config.tasks[id] ?? defaultProfile`; inactive explicit overrides remain stored.
+_Avoid_: filesystem scan, command/tool `sourceInfo` discovery, bundled consumer control planes

package/README.md

@@ -1,11 +1,11 @@
 # `@henryqw/pi-task-models`
 
-Shared `fast`, `balanced`, `frontier`, and `fav` model profiles for HenryQW Pi extensions.
+Shared `fast`, `balanced`, `frontier`, and `fav` model profiles plus routing for consumer-owned Model Tasks.
 
 ## Why
 
 - **Created for**: Deduplicating model pickers and catalogs that each extension previously owned separately.
-- **Advantage**: One shared source of `fast`/`balanced`/`frontier`/`fav` profiles keeps routing consistent across consumers.
+- **Advantage**: One shared profile control plane keeps routes consistent while each consumer owns its task identity, intent, and default profile.
 
 ## Install
 
@@ -17,23 +17,23 @@ pi install npm:@henryqw/pi-task-models
 
 | Package | Why |
 | --- | --- |
-| `@henryqw/pi-auto-compact` | Consumer. Compaction defaults to the `fast` profile. |
-| `@henryqw/pi-herdr-btw` | Consumer. Side-thread launch uses the `fast` profile. |
-| `@henryqw/pi-herdr-rename` | Consumer. Rename uses the `fast` profile. |
-| `@henryqw/pi-subagent` | Consumer. Delegation defaults to `fast`; caller may override it. |
+| `@henryqw/pi-auto-compact` | Consumer. Its local compaction task defaults to `fast`. |
+| `@henryqw/pi-herdr-btw` | Consumer. Its local side-thread task defaults to `fast`. |
+| `@henryqw/pi-herdr-rename` | Consumer. Its local rename task defaults to `fast`. |
+| `@henryqw/pi-subagent` | Consumer. Its local delegation task defaults to `fast`; callers can declare their own task. |
 | `@henryqw/pi-multi-codex` | Improves. Numbered Codex slots dedupe to one route. |
 
 ## Use
 
 | Surface | Type | Purpose |
 | --- | --- | --- |
-| `/task-models` | command | Edit a profile or assign a task to a profile. |
+| `/task-models` | command | Edit a profile or override an active task's default profile. |
 
-Selecting a profile sets primary model, primary thinking, optional fallback model, then fallback thinking. One completed flow writes the whole profile. Selecting a task changes its assignment.
+Selecting a profile sets primary model, primary thinking, optional fallback model, then fallback thinking. One completed flow writes the whole profile. Selecting an active task sets its explicit override; choosing its consumer-declared default removes that override.
 
-Menus and resolution use the current session's `ctx.scopedModels`, including pinned thinking. Empty scope uses Pi's full available model registry. Numbered Codex account aliases are deduplicated. Fallback choices exclude the selected primary. Hidden task assignments stay stored when a package is disabled. BTW selects the first authenticated viable route before pane launch.
+Consumers register their declarations at extension load. The one shared control plane asks active extensions for declarations when `/task-models` opens, so extension load order does not matter. It lists each active task's effective profile. Hidden explicit assignments stay stored when a consumer is disabled.
 
-Package also exports config and route-resolution helpers for consumers.
+Menus and resolution use the current session's `ctx.scopedModels`, including pinned thinking. Empty scope uses Pi's full available model registry. Numbered Codex account aliases are deduplicated. Fallback choices exclude the selected primary. BTW selects the first authenticated viable route before pane launch.
 
 ## Config
 
@@ -57,10 +57,7 @@ Single shared JSON file at the exact package-owned path `~/.pi/agent/config/pi-t
     }
   },
   "tasks": {
-    "pi-herdr-btw/btw": "fast",
-    "pi-herdr-rename/rename": "fast",
-    "pi-auto-compact/autoCompact": "fast",
-    "pi-subagent/delegateTask": "fast"
+    "pi-herdr-btw/btw": "balanced"
   }
 }
 ```
@@ -71,13 +68,11 @@ Single shared JSON file at the exact package-owned path `~/.pi/agent/config/pi-t
 | `profiles.<profile>.primary.model` | Yes within a configured profile's `primary` | Canonical `provider/model` reference without whitespace or NUL; available models come from Pi's model registry (or session-scoped models) at resolution time, not from this file | — |
 | `profiles.<profile>.primary.thinkingLevel` | Yes within a configured profile's `primary` | `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`; the model must support the level when the route resolves | — |
 | `profiles.<profile>.fallback` | No | When present, requires both `model` and `thinkingLevel` with the corresponding `primary.*` values; not allowed for `fav` | Omitted |
-| `tasks` | No | Object mapping task IDs (`<package>/<task>`) to a profile name | Built-in defaults listed in the example above |
-| `tasks.<taskId>` | Value required if the key is present | `fast`, `balanced`, `frontier`, `fav` | The built-in default for that task, if any |
+| `tasks` | No | Object mapping task IDs (`<package>/<task>`) to explicit user profile overrides | `{}` |
+| `tasks.<taskId>` | Value required if the key is present | `fast`, `balanced`, `frontier`, `fav` | That task declaration's `defaultProfile` |
 
-Model references use canonical `provider/model`; numbered Codex account aliases (`openai-codex-N`) resolve through Pi's registry and store canonically as `openai-codex/<model>`.
+Task defaults live only in consumer declarations. Existing explicit assignments, including one equal to a declaration's default, remain valid. Model references use canonical `provider/model`; numbered Codex account aliases (`openai-codex-N`) resolve through Pi's registry and store canonically as `openai-codex/<model>`.
 
-Reads are strict. A missing file yields no profiles and the built-in default task assignments; malformed JSON, unknown keys, invalid task IDs, unknown profiles, or invalid profile or route values fail visibly with `/task-models` guidance and never rewrite the file.
+Reads are strict. A missing file yields `{ "profiles": {}, "tasks": {} }`; malformed JSON, unknown keys, invalid task IDs, unknown profiles, or invalid profile or route values fail visibly with `/task-models` guidance and never rewrite the file.
 
-Profile thinking is authoritative for task routes.
-
-Consumers can call `resolveConfiguredTaskRoute(ctx, taskId)` for the first usable route or `resolveConfiguredTaskRoutes(ctx, taskId)` for primary and fallback routes. Both read strict shared config and fail with `/task-models` guidance when assignment, profile, or route is unavailable.
+Profile thinking is authoritative for task routes. Consumers define a `ModelTask`, call `registerModelTask(pi, task)` at extension load, then call `resolveConfiguredTaskRoute(ctx, task)` or `resolveConfiguredTaskRoutes(ctx, task)`. Resolution uses `config.tasks[task.id] ?? task.defaultProfile`.

package/dist/index.d.ts

@@ -3,12 +3,13 @@ export declare const PROFILE_NAMES: readonly ["fast", "balanced", "frontier", "f
 export type ProfileName = (typeof PROFILE_NAMES)[number];
 export declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
-export declare const DEFAULT_TASK_ASSIGNMENTS: {
-    readonly "pi-herdr-btw/btw": "fast";
-    readonly "pi-herdr-rename/rename": "fast";
-    readonly "pi-auto-compact/autoCompact": "fast";
-    readonly "pi-subagent/delegateTask": "fast";
-};
+/** A consumer-owned independently executed model operation. */
+export type ModelTask = Readonly<{
+    id: string;
+    label: string;
+    purpose: string;
+    defaultProfile: ProfileName;
+}>;
 export type TaskModelRoute = {
     model: string;
     thinkingLevel: ThinkingLevel;
@@ -19,6 +20,7 @@ export type TaskModelProfile = {
 };
 export type TaskModelsConfig = {
     profiles: Partial<Record<ProfileName, TaskModelProfile>>;
+    /** Explicit user overrides only; consumer defaults are declared at runtime. */
     tasks: Record<string, ProfileName>;
 };
 export type AvailableModel = ReturnType<ExtensionContext["modelRegistry"]["getAvailable"]>[number];
@@ -26,10 +28,6 @@ export type ResolvedTaskRoute = {
     model: AvailableModel;
     thinkingLevel: ThinkingLevel;
 };
-export type ActiveTaskPackage = {
-    packageName: string;
-    task: string;
-};
 export declare const configPath: (agentDir?: string) => string;
 export declare function readTaskModelsConfig(agentDir?: string): TaskModelsConfig;
 export declare function writeTaskModelsConfig(config: TaskModelsConfig, agentDir?: string): void;
@@ -46,15 +44,16 @@ export declare function resolveAvailableModel(models: readonly AvailableModel[],
 export declare function availableTaskModels(ctx: ExtensionContext): AvailableModel[];
 export declare function taskThinkingLevels(ctx: ExtensionContext, model: AvailableModel): ThinkingLevel[];
 export declare function resolveTaskModelRoute(ctx: ExtensionContext, route: TaskModelRoute, agentDir?: string, thinking?: ThinkingLevel): ResolvedTaskRoute | undefined;
-export declare function resolveConfiguredTaskRoutes(ctx: ExtensionContext, task: string, agentDir?: string, thinking?: ThinkingLevel): ResolvedTaskRoute[];
-export type TaskRouteErrorCode = "config-read" | "task-unassigned" | "profile-missing" | "no-route";
+export declare function resolveConfiguredTaskRoutes(ctx: ExtensionContext, task: ModelTask, agentDir?: string, thinking?: ThinkingLevel): ResolvedTaskRoute[];
+export type TaskRouteErrorCode = "config-read" | "profile-missing" | "no-route";
 export type TaskRouteError = Error & {
     taskRouteCode: TaskRouteErrorCode;
     profileName?: ProfileName;
 };
-export declare function resolveConfiguredTaskRoute(ctx: ExtensionContext, task: string, agentDir?: string, thinking?: ThinkingLevel): ResolvedTaskRoute;
+export declare function resolveConfiguredTaskRoute(ctx: ExtensionContext, task: ModelTask, agentDir?: string, thinking?: ThinkingLevel): ResolvedTaskRoute;
 export declare function orderedProfileRoutes(profile: TaskModelProfile): TaskModelRoute[];
-export declare function activeTaskPackages(pi: Pick<ExtensionAPI, "getCommands" | "getAllTools">, tasks?: Readonly<Record<string, ProfileName>>): ActiveTaskPackage[];
+/** Register one consumer-owned declaration for on-demand control-plane discovery. */
+export declare function registerModelTask(pi: Pick<ExtensionAPI, "events">, declaration: ModelTask): void;
 export declare function createTaskModelsExtension(pi: ExtensionAPI, options?: {
     agentDir?: string;
 }): void;

package/dist/index.js

@@ -4,14 +4,12 @@ import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 export const PROFILE_NAMES = ["fast", "balanced", "frontier", "fav"];
 export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-export const DEFAULT_TASK_ASSIGNMENTS = {
-    "pi-herdr-btw/btw": "fast",
-    "pi-herdr-rename/rename": "fast",
-    "pi-auto-compact/autoCompact": "fast",
-    "pi-subagent/delegateTask": "fast",
-};
 const CODEX_ALIAS = /^openai-codex-(?:[2-9]|[1-9]\d+)$/;
 const CONFIG_FILE = "pi-task-models.json";
+const MODEL_TASK_REQUEST_EVENT = "@henryqw/pi-task-models:model-task-request";
+const MODEL_TASK_RESPONSE_EVENT = "@henryqw/pi-task-models:model-task-response";
+const registeredModelTasks = new WeakMap();
+let modelTaskRequestNumber = 0;
 export const configPath = (agentDir = getAgentDir()) => join(agentDir, "config", CONFIG_FILE);
 function isCodexProvider(provider) {
     return provider === "openai-codex" || Boolean(provider && CODEX_ALIAS.test(provider));
@@ -25,6 +23,9 @@ function isThinkingLevel(value) {
 function hasOnlyKeys(value, keys) {
     return Object.keys(value).every((key) => keys.includes(key));
 }
+function hasRequiredKeys(value, keys) {
+    return hasOnlyKeys(value, keys) && keys.every((key) => Object.hasOwn(value, key));
+}
 function isModelReference(value) {
     return typeof value === "string"
         && value === value.trim()
@@ -34,6 +35,41 @@ function isModelReference(value) {
 function isTaskId(value) {
     return /^[a-z0-9][a-z0-9-]*\/[A-Za-z0-9][A-Za-z0-9-]*$/.test(value);
 }
+function isNonEmptyText(value) {
+    return typeof value === "string"
+        && value === value.trim()
+        && value.length > 0
+        && !/[\u0000-\u001f\u007f-\u009f]/.test(value);
+}
+function parseModelTask(value) {
+    try {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return;
+        const task = value;
+        if (!hasRequiredKeys(task, ["id", "label", "purpose", "defaultProfile"])
+            || !isNonEmptyText(task.id)
+            || !isTaskId(task.id)
+            || !isNonEmptyText(task.label)
+            || !isNonEmptyText(task.purpose)
+            || !isProfileName(task.defaultProfile))
+            return;
+        return {
+            id: task.id,
+            label: task.label,
+            purpose: task.purpose,
+            defaultProfile: task.defaultProfile,
+        };
+    }
+    catch {
+        return;
+    }
+}
+function validatedModelTask(value) {
+    const task = parseModelTask(value);
+    if (!task)
+        throw new Error("Model Task declaration is invalid.");
+    return task;
+}
 function isTaskRoute(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
@@ -69,7 +105,7 @@ function parseConfig(value) {
     if (!hasOnlyKeys(record, ["profiles", "tasks"]))
         throw new Error("Config contains unknown settings.");
     const profiles = {};
-    const tasks = { ...DEFAULT_TASK_ASSIGNMENTS };
+    const tasks = {};
     if (record.profiles !== undefined) {
         if (!record.profiles || typeof record.profiles !== "object" || Array.isArray(record.profiles)) {
             throw new Error("profiles must be an object.");
@@ -107,7 +143,7 @@ export function readTaskModelsConfig(agentDir = getAgentDir()) {
     }
     catch (error) {
         if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-            return { profiles: {}, tasks: { ...DEFAULT_TASK_ASSIGNMENTS } };
+            return { profiles: {}, tasks: {} };
         }
         throw error;
     }
@@ -200,6 +236,7 @@ export function resolveTaskModelRoute(ctx, route, agentDir = getAgentDir(), thin
     return { model, thinkingLevel: route.thinkingLevel };
 }
 export function resolveConfiguredTaskRoutes(ctx, task, agentDir = getAgentDir(), thinking) {
+    const declaration = validatedModelTask(task);
     let config;
     try {
         config = readTaskModelsConfig(agentDir);
@@ -207,12 +244,10 @@ export function resolveConfiguredTaskRoutes(ctx, task, agentDir = getAgentDir(),
     catch {
         throw taskRouteError("config-read", "Couldn't read task model config. Run /task-models.");
     }
-    const profileName = config.tasks[task];
-    if (!profileName)
-        throw taskRouteError("task-unassigned", `Task ${task} is not assigned to a profile. Run /task-models.`);
+    const profileName = config.tasks[declaration.id] ?? declaration.defaultProfile;
     const profile = config.profiles[profileName];
     if (!profile)
-        throw taskRouteError("profile-missing", `Task ${task} profile ${profileName} is not configured. Run /task-models.`, profileName);
+        throw taskRouteError("profile-missing", `Task ${declaration.id} profile ${profileName} is not configured. Run /task-models.`, profileName);
     const routes = [];
     for (const route of orderedProfileRoutes(profile)) {
         const resolved = resolveTaskModelRoute(ctx, route, agentDir, thinking);
@@ -220,7 +255,7 @@ export function resolveConfiguredTaskRoutes(ctx, task, agentDir = getAgentDir(),
             routes.push(resolved);
     }
     if (!routes.length) {
-        throw taskRouteError("no-route", `Task ${task} profile ${profileName} has no available route${thinking ? ` supporting thinking ${thinking}` : ""}. Run /task-models.`, profileName);
+        throw taskRouteError("no-route", `Task ${declaration.id} profile ${profileName} has no available route${thinking ? ` supporting thinking ${thinking}` : ""}. Run /task-models.`, profileName);
     }
     return routes;
 }
@@ -233,28 +268,86 @@ export function resolveConfiguredTaskRoute(ctx, task, agentDir = getAgentDir(),
 export function orderedProfileRoutes(profile) {
     return profile.fallback ? [profile.primary, profile.fallback] : [profile.primary];
 }
-export function activeTaskPackages(pi, tasks = DEFAULT_TASK_ASSIGNMENTS) {
-    const sources = [
-        ...pi.getCommands().map((command) => command.sourceInfo),
-        ...pi.getAllTools().map((tool) => tool.sourceInfo),
-    ];
-    return Object.keys(tasks).flatMap((task) => {
-        if (!isTaskId(task))
-            return [];
-        const packageName = `@henryqw/${task.slice(0, task.indexOf("/"))}`;
-        return sources.some((source) => sourceMatchesPackage(source, packageName))
-            ? [{ packageName, task }]
-            : [];
+function sameModelTask(left, right) {
+    return left.id === right.id
+        && left.label === right.label
+        && left.purpose === right.purpose
+        && left.defaultProfile === right.defaultProfile;
+}
+function parseModelTaskDiscoveryRequest(value) {
+    try {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return;
+        const request = value;
+        return hasRequiredKeys(request, ["requestId"]) && isNonEmptyText(request.requestId)
+            ? { requestId: request.requestId }
+            : undefined;
+    }
+    catch {
+        return;
+    }
+}
+function parseModelTaskDiscoveryResponse(value) {
+    try {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return;
+        const response = value;
+        if (!hasRequiredKeys(response, ["requestId", "task"]) || !isNonEmptyText(response.requestId))
+            return;
+        const task = parseModelTask(response.task);
+        return task ? { requestId: response.requestId, task } : undefined;
+    }
+    catch {
+        return;
+    }
+}
+/** Register one consumer-owned declaration for on-demand control-plane discovery. */
+export function registerModelTask(pi, declaration) {
+    const task = validatedModelTask(declaration);
+    let tasks = registeredModelTasks.get(pi);
+    if (!tasks) {
+        tasks = new Map();
+        registeredModelTasks.set(pi, tasks);
+    }
+    const existing = tasks.get(task.id);
+    if (existing) {
+        if (!sameModelTask(existing, task))
+            throw new Error(`Conflicting Model Task declaration: ${task.id}.`);
+        return;
+    }
+    tasks.set(task.id, task);
+    pi.events.on(MODEL_TASK_REQUEST_EVENT, (payload) => {
+        // Event payloads cross extension boundaries and are not trusted.
+        const request = parseModelTaskDiscoveryRequest(payload);
+        if (!request)
+            return;
+        pi.events.emit(MODEL_TASK_RESPONSE_EVENT, { requestId: request.requestId, task });
     });
 }
-function sourceMatchesPackage(sourceInfo, packageName) {
-    const npmSource = `npm:${packageName}`;
-    if (sourceInfo.source === packageName || sourceInfo.source === npmSource || sourceInfo.source.startsWith(`${npmSource}@`))
-        return true;
-    const path = sourceInfo.path.replaceAll("\\", "/");
-    const shortName = packageName.split("/").pop();
-    return path.includes(`/node_modules/${packageName}/`)
-        || Boolean(shortName && path.includes(`/packages/${shortName}/`));
+function discoverModelTasks(pi) {
+    const requestId = `model-task-${++modelTaskRequestNumber}`;
+    const tasks = new Map();
+    const conflicts = new Set();
+    const off = pi.events.on(MODEL_TASK_RESPONSE_EVENT, (payload) => {
+        // Event payloads cross extension boundaries and are not trusted.
+        const response = parseModelTaskDiscoveryResponse(payload);
+        if (!response || response.requestId !== requestId)
+            return;
+        const existing = tasks.get(response.task.id);
+        if (existing && !sameModelTask(existing, response.task))
+            conflicts.add(response.task.id);
+        else
+            tasks.set(response.task.id, response.task);
+    });
+    try {
+        pi.events.emit(MODEL_TASK_REQUEST_EVENT, { requestId });
+    }
+    finally {
+        off();
+    }
+    if (conflicts.size)
+        throw new Error(`Conflicting Model Task declarations: ${[...conflicts].join(", ")}.`);
+    return [...tasks.values()].sort((left, right) => left.id.localeCompare(right.id));
 }
 export function createTaskModelsExtension(pi, options) {
     const agentDir = options?.agentDir ?? getAgentDir();
@@ -288,25 +381,28 @@ export function createTaskModelsExtension(pi, options) {
                     return false;
                 }
             };
-            const taskOptions = activeTaskPackages(pi, config.tasks).map((entry) => ({
-                entry,
-                label: `${entry.task} · ${config.tasks[entry.task]}`,
-            }));
+            const taskOptions = discoverModelTasks(pi).map((task) => {
+                const profile = config.tasks[task.id] ?? task.defaultProfile;
+                return { task, label: `${task.label} · ${task.id} · ${profile}` };
+            });
             const selected = await ctx.ui.select("Task models", [
                 ...profileOptions.map(({ label }) => label),
                 ...taskOptions.map(({ label }) => label),
             ]);
             if (!selected)
                 return;
-            const task = taskOptions.find(({ label }) => label === selected)?.entry;
+            const task = taskOptions.find(({ label }) => label === selected)?.task;
             if (task) {
-                const profile = await ctx.ui.select(`${task.task} profile`, [...PROFILE_NAMES]);
+                const profile = await ctx.ui.select(`${task.label}: ${task.purpose}`, [...PROFILE_NAMES]);
                 if (!isProfileName(profile))
                     return;
-                config.tasks[task.task] = profile;
+                if (profile === task.defaultProfile)
+                    delete config.tasks[task.id];
+                else
+                    config.tasks[task.id] = profile;
                 if (!save())
                     return;
-                ctx.ui.notify(`${task.task} assigned to ${profile}.`, "info");
+                ctx.ui.notify(`${task.id} assigned to ${profile}.`, "info");
                 return;
             }
             const profile = profileOptions.find(({ label }) => label === selected)?.name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-task-models",
-  "version": "2.0.0",
+  "version": "3.0.1",
   "description": "Shared task model profiles and routing for HenryQW Pi extensions.",
   "keywords": [
     "pi-package",
@@ -35,8 +35,8 @@
     "pack:check": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "^0.84.3",
-    "@earendil-works/pi-coding-agent": "^0.84.3"
+    "@earendil-works/pi-ai": "^0.84.4",
+    "@earendil-works/pi-coding-agent": "^0.84.4"
   },
   "repository": {
     "type": "git",