@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/kanboard/src/settings.ts

@@ -2,7 +2,8 @@
  * @pi-unipi/kanboard — settings (hub section "Kanboard").
  */
 
-import { getSettings, registerCommandRunner, registerSettings, setSettings } from "@pi-unipi/core";
+import { existsSync, readFileSync } from "node:fs";
+import { getSettings, globalSettingsPath, projectSettingsPath, registerCommandRunner, registerSettings, setSettings } from "@pi-unipi/core";
 
 export type ChainGate = "in_review" | "done";
 
@@ -25,12 +26,20 @@ export interface KanboardSettings {
   requireAuth: boolean;
   /** Reuse <home>/token so board links survive daemon restarts. */
   keepToken: boolean;
-  /** Tasks one session may queue (0 = unlimited). */
-  queueMax: number;
   /** Distinct sessions running tasks per project (min 1). */
   maxSessions: number;
-  /** `add` calls allowed per -do/runner window (0 = unlimited). */
+  /** `add` calls allowed per turn (0 = unlimited). */
   turnAddLimit: number;
+  /** Task slots a /unipi:kanboard-do grants (each `start` uses one). */
+  doTasks: number;
+  /** Board writes a /unipi:kanboard-do grants. */
+  doWrites: number;
+  /** Whether a blocked-by-confusion task may ask the user (ask) or must
+   *  assume-and-note (avoid, the default). */
+  blocking: "avoid" | "ask";
+  /** Progress reminders when the agent works board tasks by hand: `start`
+   *  before the first edit, `finish` (or block) before the turn ends. */
+  reminders: boolean;
 }
 
 export const DEFAULT_SETTINGS: KanboardSettings = {
@@ -43,9 +52,12 @@ export const DEFAULT_SETTINGS: KanboardSettings = {
   openBrowser: false,
   requireAuth: false,
   keepToken: false,
-  queueMax: 10,
   maxSessions: 2,
   turnAddLimit: 20,
+  doTasks: 5,
+  doWrites: 10,
+  blocking: "avoid",
+  reminders: true,
 };
 
 export const KANBOARD_NAMESPACE = "kanboard";
@@ -59,11 +71,11 @@ export function registerKanboardSettings(): void {
   registerSettings({
     namespace: KANBOARD_NAMESPACE,
     label: "Kanboard",
-    defaults: DEFAULT_SETTINGS as unknown as Record<string, unknown>,
+    defaults: { ...DEFAULT_SETTINGS } as unknown as Record<string, unknown>,
     schema: [
       {
         title: "Kanboard",
-        description: "Deferred-work board: task runner, daemon and skill",
+        description: "The session's work board: daemon, -do budgets and skill",
         fields: [
           {
             key: "chainGate",
@@ -100,12 +112,16 @@ export function registerKanboardSettings(): void {
             label: "Keep the access token across restarts",
             description: "Reuse one token so board links stay valid; rotate it below.",
           },
-          { key: "queueMax", type: "number", label: "-do queue limit", min: 0, zeroLabel: "unlimited", description: "Tasks a session may queue for the runner" },
           { key: "maxSessions", type: "number", label: "Sessions working at once (per project)", min: 1, description: "Distinct sessions holding in_progress tasks" },
-          { key: "turnAddLimit", type: "number", label: "New tasks per turn", min: 0, zeroLabel: "unlimited", description: "`add` calls allowed per -do turn or runner task" },
-          { key: "open", type: "action", label: "Open board…", description: "Start the daemon and print the URL", command: ACTION_OPEN },
-          { key: "stopDaemon", type: "action", label: "Stop daemon", description: "Terminate the running kanboard daemon", command: ACTION_STOP_DAEMON },
-          { key: "rotateToken", type: "action", label: "Rotate access token", description: "Drop the persistent token; a fresh one mints on the next daemon start", command: ACTION_ROTATE_TOKEN },
+          { key: "turnAddLimit", type: "number", label: "New tasks per turn", min: 0, zeroLabel: "unlimited", description: "`add` calls allowed per turn" },
+          {
+            key: "reminders",
+            type: "boolean",
+            label: "Progress reminders",
+            description: "Remind the agent to `start` a mentioned Todo task before editing (text only, never blocks; off in child sessions)",
+          },
+          { key: "doTasks", type: "number", label: "-do task slots", min: 0, zeroLabel: "off", description: "Task slots a /unipi:kanboard-do grants; each `start` uses one" },
+          { key: "doWrites", type: "number", label: "-do write budget", min: 0, zeroLabel: "off", description: "Board writes a /unipi:kanboard-do grants (add, edit, link, order, move, note on tasks you don't hold)" },
         ],
       },
     ],
@@ -127,9 +143,18 @@ export function readKanboardSettings(cwd: string = process.cwd()): KanboardSetti
     openBrowser: raw.openBrowser === true,
     requireAuth: raw.requireAuth === true,
     keepToken: raw.keepToken === true,
-    queueMax: typeof raw.queueMax === "number" && raw.queueMax >= 0 ? raw.queueMax : DEFAULT_SETTINGS.queueMax,
     maxSessions: typeof raw.maxSessions === "number" && raw.maxSessions >= 1 ? raw.maxSessions : DEFAULT_SETTINGS.maxSessions,
     turnAddLimit: typeof raw.turnAddLimit === "number" && raw.turnAddLimit >= 0 ? raw.turnAddLimit : DEFAULT_SETTINGS.turnAddLimit,
+    // Migration: getSettings merges defaults, so a stored doCredits hides
+    // behind the doWrites default. Look at the stored layer for the legacy key
+    // (project first, then global) — the next settings write persists doWrites.
+    doTasks: typeof raw.doTasks === "number" && raw.doTasks >= 0 ? raw.doTasks : DEFAULT_SETTINGS.doTasks,
+    doWrites:
+      typeof raw.doWrites === "number" && raw.doWrites >= 0 && storedDoWritesSet(cwd)
+        ? raw.doWrites
+        : (storedLegacyDoCredits(cwd) ?? DEFAULT_SETTINGS.doWrites),
+    blocking: raw.blocking === "ask" ? "ask" : "avoid",
+    reminders: raw.reminders !== false,
   };
 }
 
@@ -137,6 +162,35 @@ export function writeKanboardSettings(patch: Partial<KanboardSettings>, cwd: str
   setSettings(KANBOARD_NAMESPACE, patch as unknown as Record<string, unknown>, "global", cwd);
 }
 
+/** Whether any stored layer carries an explicit doWrites (defaults don't count). */
+function storedDoWritesSet(cwd: string): boolean {
+  for (const file of [projectSettingsPath(cwd, KANBOARD_NAMESPACE), globalSettingsPath(KANBOARD_NAMESPACE)]) {
+    try {
+      if (!existsSync(file)) continue;
+      const parsed = JSON.parse(readFileSync(file, "utf-8")) as Record<string, unknown>;
+      if (typeof parsed.doWrites === "number") return true;
+    } catch {
+      // A corrupt file has no legacy value either.
+    }
+  }
+  return false;
+}
+
+/** The pre-slot doCredits value from the stored layers, if any. */
+function storedLegacyDoCredits(cwd: string): number | undefined {
+  for (const file of [projectSettingsPath(cwd, KANBOARD_NAMESPACE), globalSettingsPath(KANBOARD_NAMESPACE)]) {
+    try {
+      if (!existsSync(file)) continue;
+      const parsed = JSON.parse(readFileSync(file, "utf-8")) as Record<string, unknown>;
+      const value = parsed.doCredits;
+      if (typeof value === "number" && value >= 0) return value;
+    } catch {
+      // A corrupt file has no legacy value either.
+    }
+  }
+  return undefined;
+}
+
 /** Re-exported so index.ts and tests share one registration path. */
 export function registerKanboardRunners(runners: {
   open: (ctx: unknown) => void | Promise<void>;
@@ -150,9 +204,9 @@ export function registerKanboardRunners(runners: {
 
 /**
  * Limits reach the Rust CLI through the environment — refresh the process-wide
- * values so the agent's bash calls and the runner's CLI calls both see them.
+ * values so the agent's bash calls and spawned CLI calls both see them.
+ * (queueMax died with the runner; the binary's queue limit is untouched.)
  */
 export function applyLimitEnv(settings: KanboardSettings): void {
-  process.env.UNIPI_KANBOARD_QUEUE_MAX = String(settings.queueMax);
   process.env.UNIPI_KANBOARD_MAX_SESSIONS = String(settings.maxSessions);
 }

package/packages/kanboard/src/shapes.ts

@@ -32,6 +32,8 @@ export interface KanboardRun {
   mode?: string;
   goal?: string | null;
   started?: string;
+  /** "system" (runner claim) or "agent" (`start` self-claim). */
+  owner?: string;
 }
 
 export interface KanboardActivity {
@@ -43,6 +45,8 @@ export interface KanboardActivity {
 export interface KanboardTask {
   id: string;
   title: string;
+  /** Title derived from the first body line when `title` is empty (Rust `Task::display_title`). */
+  displayTitle?: string;
   body?: string;
   status: string;
   priority?: string;
@@ -113,6 +117,7 @@ export function asTask(command: string, value: unknown): KanboardTask {
     ...record,
     id: requireString(command, record, "id"),
     title: requireString(command, record, "title"),
+    displayTitle: typeof record.displayTitle === "string" ? record.displayTitle : undefined,
     status: requireString(command, record, "status"),
     deps: optionalArray<string>(record.deps) ?? [],
     activity: optionalArray<KanboardActivity>(record.activity) ?? [],

package/packages/long-horizon/index.ts

@@ -10,20 +10,23 @@ import { existsSync, renameSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { Text } from "@earendil-works/pi-tui";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { emitEvent, getPackageVersion, registerCommandRunner, stateDir, UNIPI_EVENTS, setSharedLongHorizonMode } from "@pi-unipi/core";
+import { appendProgress, emitEvent, getPackageVersion, harnessMetadata, installArbiter, registerCommandRunner, registerCompactionContext, registerNudgeProvider, sendHarnessUserMessage, stateDir, UNIPI_EVENTS, setSharedLongHorizonMode } from "@pi-unipi/core";
+import { longHorizonCompactionBrief } from "./src/compaction-brief.js";
 import { OwnerCoordinator, type OwnerEvent } from "./src/owner.js";
 import { Gate } from "./src/gate.js";
-import { registerLongHorizonCommands } from "./src/commands.js";
+import { registerLongHorizonCommands, stopActiveOwner } from "./src/commands.js";
 import { loadSettings } from "./src/settings.js";
 import { GoalMachine } from "./src/engine/goal-state.js";
 import { GoalToolset } from "./src/tools/goal.js";
 import { GoalContinuation } from "./src/engine/continuation.js";
+import { NudgeStash, nextStashMetaState, ownerEventClearsStash, type StashMetaState } from "./src/engine/nudge-stash.js";
 import { RalphLoop } from "./src/engine/ralph.js";
 import { registerRalphTools } from "./src/tools/ralph.js";
 import { SwarmLedger, registerSwarmTools } from "./src/tools/swarm.js";
 import { GraphLedger, registerGraphTools } from "./src/tools/graph.js";
 import { TodoStore, registerTodoTool } from "./src/tools/todo.js";
 import { wireRuntime } from "./src/runtime.js";
+import { ralphProgressData } from "./src/progress.js";
 
 export * from "./src/modes.js";
 export * from "./src/owner.js";
@@ -56,10 +59,29 @@ export default function longHorizon(pi: ExtensionAPI): void {
   const version = getPackageVersion("long-horizon");
   const statePath = () => lhStatePath("state.json");
 
+  // Standalone loads (`-e long-horizon/index.ts`) must install the arbiter
+  // themselves; the umbrella installs it before modules mount, and this call
+  // is a no-op there (holder flag).
+  try {
+    installArbiter(pi);
+  } catch {
+    // Never block module load on the arbiter.
+  }
+
   // Owner lifecycle → unipi event bus (footer/info-screen consume these).
+  // A finished or parked owner invalidates an undelivered nudge (declared
+  // before `owner` so the onChange closure can clear it).
+  const stash = new NudgeStash();
+  // Provenance mirror state lives with the stash (declared BEFORE the owner
+  // constructor — its onChange may fire immediately).
+  let stashMetaState: StashMetaState<ReturnType<typeof harnessMetadata>> = { meta: undefined, kickoff: false };
   const owner = new OwnerCoordinator({
     statePath,
     onChange: (_snapshot, event: OwnerEvent) => {
+      if (ownerEventClearsStash(event)) {
+        stash.take();
+        stashMetaState = { meta: undefined, kickoff: false };
+      }
       emitEvent(pi, UNIPI_EVENTS.LONG_HORIZON_OWNER_CHANGED, {
         event: event.type,
         ...("owner" in event && event.owner
@@ -108,7 +130,9 @@ export default function longHorizon(pi: ExtensionAPI): void {
                 ? "active owner"
                 : data.source === "judge_abstained_low_confidence"
                   ? "judge abstained → default"
-                  : "default";
+                  : data.source === "child"
+                    ? "child agent"
+                    : "default";
         const line = `${t.fg?.("customMessageText", badge) ?? badge} ${t.fg?.("dim", via) ?? via}`;
         return new Text(line, 0, 0);
       },
@@ -117,6 +141,66 @@ export default function longHorizon(pi: ExtensionAPI): void {
     // Renderer registration is UI-dependent; skip where unavailable.
   }
 
+  // ── messaging: nudge stash, not the message queue ──────────────────
+  // Continuation/ralph sends land in a one-slot stash; the arbiter delivers
+  // it as the single before_settle nudge (priority 100) and takes it.
+  // Timer wakes while idle (waiting-backoff) stay direct sends: they are
+  // events, and nothing would settle to drain the stash for them.
+  // (`stash` is declared above the owner so owner stops can clear it.)
+  let runActive = false;
+  try {
+    pi.on("agent_start", () => {
+      runActive = true;
+    });
+    pi.on("agent_settled", () => {
+      runActive = false;
+    });
+  } catch {
+    // Idle tracking must never block load.
+  }
+  const send: (message: string, kind?: "kickoff", meta?: { source: string; title: string; synopsis?: string; severity?: "warning" }) => void = (
+    message,
+    kind,
+    meta,
+  ) => {
+    const next = nextStashMetaState(stashMetaState, stash.peek() !== null, kind, harnessMetadata(meta ?? { source: "Goal", title: kind === "kickoff" ? "Kickoff" : "Continuation" }, "boundary"));
+    stashMetaState = next;
+    stash.put(message, kind === "kickoff" ? { kickoff: true } : {});
+  };
+  const sendNow = (message: string, meta?: { source: string; title: string; synopsis?: string; severity?: "warning" }): void => {
+    try {
+      const options = runActive ? { deliverAs: "followUp" as const } : undefined;
+      sendHarnessUserMessage(
+        pi,
+        message,
+        meta ?? { source: "Goal", title: "Continuation" },
+        options,
+      );
+    } catch {
+      // A failed wake must never crash the session.
+    }
+  };
+  try {
+    registerNudgeProvider("long-horizon", 100, () => {
+      const text = stash.peek();
+      if (text === null) return null;
+      return {
+        source: "long-horizon",
+        priority: 100,
+        customType: "unipi:lh-continue",
+        content: text,
+        display: true,
+        ...(stashMetaState.meta !== undefined ? { details: { unipiHarness: stashMetaState.meta } } : {}),
+        onDelivered: () => {
+          stash.take();
+          stashMetaState = { meta: undefined, kickoff: false };
+        },
+      };
+    });
+  } catch {
+    // Registration must never block load.
+  }
+
   // Goal engine: machine + tools + continuation + runtime wiring.
   const machine = new GoalMachine({
     statePath: () => lhStatePath("goal.json"),
@@ -130,18 +214,18 @@ export default function longHorizon(pi: ExtensionAPI): void {
     toolset,
     owner,
     verifier: { evaluate: async () => { throw new Error("verifier unbound"); } },
-    send: (message) => {
-      void pi.sendUserMessage(message);
-    },
+    // Continuation messages ride the arbiter's nudge stash (delivered as the
+    // single before_settle nudge); timer wakes use sendNow directly.
+    send,
+    sendNow,
   });
   // Ralph loop rides the same goal machine + verifier; footer events preserved.
   const ralph = new RalphLoop({
     machine,
     owner,
     ralphDir: () => join(stateDir("long-horizon", "state"), "ralph"),
-    send: (message) => {
-      void pi.sendUserMessage(message);
-    },
+    // Iteration prompts ride the arbiter's nudge stash like the goal's.
+    send: (message, kind) => send(message, kind, { source: "Ralph", title: "Iteration", synopsis: "Loop iteration prompt" }),
     onEvent: (event) => {
       if (event.type === "loop_start") {
         emitEvent(pi, UNIPI_EVENTS.RALPH_LOOP_START, { name: event.name, iteration: event.iteration, total: event.total });
@@ -150,6 +234,9 @@ export default function longHorizon(pi: ExtensionAPI): void {
       } else if (event.type === "loop_end") {
         emitEvent(pi, UNIPI_EVENTS.RALPH_LOOP_END, { name: event.name, reason: event.reason, iterations: event.iterations });
       }
+      // User-only progress bar on every loop update.
+      const bar = ralphProgressData(ralph);
+      if (bar) appendProgress(pi, bar);
     },
   });
   registerRalphTools(pi, ralph);
@@ -157,7 +244,11 @@ export default function longHorizon(pi: ExtensionAPI): void {
   registerSwarmTools(pi, { ledger: swarm, owner });
   const graph = new GraphLedger(owner);
   registerGraphTools(pi, { ledger: graph });
-  wireRuntime(pi, { machine, toolset, continuation, gate, loadSettings, ralph });
+  const runtime = wireRuntime(pi, { machine, toolset, continuation, gate, loadSettings, ralph });
+  // Compaction summaries lead with the live goal / ralph state.
+  registerCompactionContext("long-horizon", () =>
+    longHorizonCompactionBrief(machine.getActive(), ralph.get(), join(stateDir("long-horizon", "state"), "ralph")),
+  );
 
   // Cross-module entry points: another module (kanboard's runner) can start a
   // goal and read its status without importing this package. Mirrors what the
@@ -196,9 +287,91 @@ export default function longHorizon(pi: ExtensionAPI): void {
     if (typeof goalId === "string" && goalId.length > 0 && goal.goalId !== goalId) {
       return { found: false, reason: `the active goal is ${goal.goalId}` };
     }
-    return { found: true, goalId: goal.goalId, status: goal.status, objective: goal.objective };
+    return { found: true, goalId: goal.goalId, status: goal.status, reason: goal.reason, objective: goal.objective };
+  });
+
+  // kanboard runner bridge: pause/resume/stop the goal around task releases
+  // and re-claims, so an interrupted task keeps its goal for the next claim.
+  registerCommandRunner("unipi:goal-pause", async (_ctx, args) => {
+    const goal = machine.get();
+    const active = owner.getActive();
+    if (!goal || goal.status !== "active" || active?.kind !== "goal") {
+      return { ok: false, reason: goal ? `goal is ${goal.status}` : "no goal in this session" };
+    }
+    const requested = (args as { goalId?: unknown } | undefined)?.goalId;
+    if (typeof requested === "string" && requested.length > 0 && requested !== goal.goalId) {
+      return { ok: false, reason: `the active goal is ${goal.goalId}` };
+    }
+    const paused = machine.pause("paused(user_requested)");
+    if (!paused) return { ok: false, reason: `goal is ${goal.status}` };
+    const parked = owner.suspend("paused(user_requested)");
+    if (!parked) {
+      // Slot held: the goal stays paused but unowned — resume reactivates it.
+      emitEvent(pi, UNIPI_EVENTS.LONG_HORIZON_OWNER_CHANGED, { event: "suspended", kind: "goal" });
+    }
+    return { ok: true, goalId: paused.goalId, status: paused.status };
   });
-  registerLongHorizonCommands(pi, gate, owner, ralph);
+
+  registerCommandRunner("unipi:goal-resume", async (_ctx, args) => {
+    const goal = machine.get();
+    const requested = (args as { goalId?: unknown } | undefined)?.goalId;
+    if (!goal) return { ok: false, reason: "no goal in this session" };
+    if (goal.status !== "paused") return { ok: false, reason: `goal is ${goal.status}, not paused` };
+    if (typeof requested === "string" && requested.length > 0 && requested !== goal.goalId) {
+      return { ok: false, reason: `the parked goal is ${goal.goalId}` };
+    }
+    const resumed = machine.resume();
+    if (!resumed) return { ok: false, reason: "goal could not be resumed" };
+    if (owner.getParked()) owner.resume();
+    gate.setExplicit("goal");
+    return { ok: true, goalId: resumed.goalId, status: resumed.status };
+  });
+
+  registerCommandRunner("unipi:goal-stop", async (_ctx, args) => {
+    const goal = machine.get();
+    const requested = (args as { goalId?: unknown } | undefined)?.goalId;
+    if (typeof requested === "string" && requested.length > 0 && goal && requested !== goal.goalId) {
+      return { ok: false, reason: `the goal in this session is ${goal.goalId}` };
+    }
+    const stopped = stopActiveOwner(pi, gate, owner, machine, toolset, "goal");
+    return stopped !== undefined
+      ? { ok: true, goalId: requested || goal?.goalId }
+      : { ok: false, reason: goal && goal.status === "complete" ? "goal already stopped" : "no active goal" };
+  });
+
+  // kanboard strategy runners: swarm/graph set the explicit mode for the next
+  // turn; ralph starts the checklist loop (its own kickoff prompt ships via
+  // ralph.start's send — the runner's task prompt lands behind it).
+  registerCommandRunner("unipi:lh-explicit", async (_ctx, args) => {
+    const mode = String((args as { mode?: unknown } | undefined)?.mode ?? "");
+    if (mode !== "swarm" && mode !== "graph" && mode !== "goal" && mode !== "none") {
+      return { ok: false, reason: `unknown mode "${mode}"` };
+    }
+    if (mode !== "none" && owner.getActive() && owner.getActive()?.kind !== mode) {
+      return {
+        ok: false,
+        reason: `the session is owned by a ${owner.getActive()?.kind} owner — finish or suspend it first`,
+      };
+    }
+    gate.setExplicit(mode);
+    return { ok: true, mode };
+  });
+
+  registerCommandRunner("unipi:ralph-start", async (_ctx, args) => {
+    const a = (args ?? {}) as { name?: unknown; content?: unknown };
+    const name = String(a.name ?? "").trim();
+    const content = String(a.content ?? "");
+    if (!name || !content.trim()) {
+      return { ok: false, reason: "name and content are required" };
+    }
+    return ralph.start(name, content);
+  });
+
+  registerLongHorizonCommands(pi, gate, owner, ralph, {
+    ralphBar: () => ralphProgressData(ralph),
+    estimateGoal: (ctx) => runtime.estimateGoal(ctx),
+    goalEstimateOn: () => loadSettings().goalProgress !== "off",
+  }, machine, toolset);
 
   // Crash recovery: repair, don't resume — reload durable state so the gate
   // reattaches the owner's tool surface; the continuation arms a recovery
@@ -206,7 +379,10 @@ export default function longHorizon(pi: ExtensionAPI): void {
   pi.on("session_start", () => {
     const restored = owner.restore();
     machine.restore();
-    if (machine.getActive()) continuation.armRecovery();
+    // Only a truly drivable goal arms the recovery fragment; a paused goal
+    // must come back idle until the user (or the kanboard runner) resumes it.
+    const goalStatus = machine.get()?.status;
+    if (goalStatus === "active" || goalStatus === "waiting") continuation.armRecovery();
     // Resume (`pi -r`) starts no turn, so before_agent_start never fires. Publish
     // the mode to the shared holder the footer PULLS each render — the active
     // owner's mode if one survived, else the default — so the header restores
@@ -227,6 +403,7 @@ export default function longHorizon(pi: ExtensionAPI): void {
       "unipi:ralph",
       "unipi:swarm",
       "unipi:graph",
+      "unipi:regular",
     ],
     tools: ["create_goal", "get_goal", "update_goal", "todowrite", "ralph_done", "loop_status", "swarm_report", "swarm_status", "swarm_yield", "update_agent_graph", "graph_output", "view_agent_graph"],
   });

package/packages/long-horizon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/long-horizon",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.21",
   "description": "Long-horizon execution for Pi — mode-gated /goal /ralph /swarm /graph orchestration with a TypeSafe prompt judge",
   "type": "module",
   "main": "index.ts",
@@ -23,7 +23,7 @@
     "graph"
   ],
   "scripts": {
-    "test": "tsc --noEmit && npx tsx --test src/__tests__/*.test.ts",
+    "test": "tsc --noEmit && UNIPI_FUSION_CHILD= UNIPI_SUBAGENT_CHILD= UNIPI_KANBOARD_CHILD= npx tsx --test src/__tests__/*.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "files": [
@@ -37,7 +37,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0-alpha.2"
+    "@pi-unipi/core": "3.0.0-alpha.21"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",