@oisin-ee/pi-prewalk 0.7.1 → 0.8.0

package/README.md

@@ -1,6 +1,7 @@
 # @oisin-ee/pi-prewalk
 
-Prewalk starts with the active planner model. After the planning nudge, a successful `todo` call opens the handoff gate.
+Prewalk starts with the active planner model. After the planning nudge, validated local task activation opens the handoff gate.
+Without the task-provider capability, a successful `todo` call opens the gate instead. Imported workers need no bookkeeping call.
 The first subsequent `edit` or `write` result switches the session to the target model, even if that result failed.
 Nested calls through codemode also count. Without a callable `todo` tool, the gate is open.
 
@@ -27,7 +28,7 @@ The startup flags are `--prewalk`, `--no-prewalk`, and `--prewalk-into provider/
 Do not combine `--no-prewalk` with either arming flag.
 Flags affect only the startup session. New sessions use `enabled` from config. Resumed sessions do not arm automatically.
 
-For a wrangle child, add `"pi_args": ["--prewalk-into", "alias/luna"]` to its profile.
+For a dogsled child, add `"pi_args": ["--prewalk-into", "alias/luna"]` to its profile.
 To suppress configured prewalk for that child, use `"pi_args": ["--no-prewalk"]`.
 
 ## State and context

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/pi-prewalk",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "A one-shot planner-to-executor handoff for pi, with branch-backed Rust rules.",
   "keywords": [
     "pi-extension",

package/src/adapter.ts

@@ -4,6 +4,7 @@ import type { BoundaryResult, SessionBoundaryDraft } from "@earendil-works/pi-co
 import type { Context, Files, Host } from "./ports.ts";
 import { branchRecords, calls } from "./branch.ts";
 import type { CallEvidence } from "./branch.ts";
+import { activeTask } from "./tasks.ts";
 import { decide } from "./wasm.ts";
 
 /**
@@ -117,6 +118,7 @@ class Adapter {
           todo.exposure === "deferred" ||
           this.#pi.getActiveTools().includes("todo"));
     return {
+      active_unit: activeTask(this.#pi.events),
       available: ctx.modelRegistry
         .getAvailable()
         .map((candidate) => `${candidate.provider}/${candidate.id}`),

package/src/generated/prewalk_core.d.ts

@@ -55,6 +55,10 @@ export interface Facts {
      * Is todo callable (directly or through codemode)?
      */
     todo: boolean;
+    /**
+     * Current provider activation; absent preserves the legacy successful-todo rule.
+     */
+    active_unit?: boolean | undefined;
     /**
      * Todo source identity for status.
      */

package/src/ports.ts

@@ -12,7 +12,7 @@ type Host = Pick<
   | "getThinkingLevel"
   | "setThinkingLevel"
   | "setModel"
->;
+> & { readonly events: Readonly<ExtensionAPI["events"]> };
 /** Read-only pi facts. */
 interface Context {
   readonly cwd: string;

package/src/tasks.ts

@@ -0,0 +1,48 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+interface ActiveProvider {
+  readonly active: () => unknown;
+}
+
+/**
+ * Validates only the capability method this consumer needs.
+ * @param {unknown} value Capability response.
+ * @returns {boolean} Whether the active query is callable.
+ */
+const isProvider = (value: unknown): value is ActiveProvider =>
+    typeof value === "object" &&
+    value !== null &&
+    "active" in value &&
+    typeof value.active === "function",
+  /**
+   * Queries current activation without loading todo or interpreting its snapshots.
+   * @param {Readonly<ExtensionAPI["events"]>} events Extension capability bus.
+   * @returns {boolean | undefined} Activation, or unavailable legacy capability.
+   */
+  activeTask = (events: Readonly<ExtensionAPI["events"]>): boolean | undefined => {
+    const replies: unknown[] = [];
+    events.emit("oisin.tasks.acquire.v1", {
+      reply: (provider: unknown): void => {
+        replies.push(provider);
+      },
+      version: 1,
+    });
+    const [provider] = replies,
+      one = 1;
+    if (replies.length !== one || !isProvider(provider)) {
+      return undefined;
+    }
+    const result: unknown = provider.active();
+    if (
+      typeof result !== "object" ||
+      result === null ||
+      !("ok" in result) ||
+      result.ok !== true ||
+      !("value" in result)
+    ) {
+      return undefined;
+    }
+    return result.value !== null && result.value !== undefined;
+  };
+
+export { activeTask };