@oisin-ee/oisinpi 0.7.2 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @oisin-ee/oisinpi
 
+## 0.8.0
+
+### Patch Changes
+
+- Updated dependencies [[`50877ec`](https://github.com/oisin-ee/oisinpi/commit/50877ec0f9bba71b7f70d8bf8d3754191ac73364)]:
+  - @oisin-ee/pi-todo@0.8.0
+  - @oisin-ee/pi-prewalk@0.8.0
+  - @oisin-ee/pi-guardrails@0.8.0
+
 ## 0.7.2
 
 ### Patch Changes

package/node_modules/@oisin-ee/pi-guardrails/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/pi-guardrails",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Agent guardrails for pi, Claude Code, and Codex: Git safety, no waiting, no typing into other agents, GitOps-only clusters.",
   "keywords": [
     "claude-code",

package/node_modules/@oisin-ee/pi-prewalk/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.
 

package/node_modules/@oisin-ee/pi-prewalk/package.json

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

package/node_modules/@oisin-ee/pi-prewalk/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/node_modules/@oisin-ee/pi-prewalk/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/node_modules/@oisin-ee/pi-prewalk/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/node_modules/@oisin-ee/pi-prewalk/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 };

package/node_modules/@oisin-ee/pi-todo/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/pi-todo",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "A todo tool for pi with a Rust core: one active task, state on the session branch.",
   "keywords": [
     "pi-extension",

package/node_modules/@oisin-ee/pi-todo/src/contract-fixture.ts

@@ -0,0 +1,103 @@
+import type { TodoParams, TodoSession } from "./tool.ts";
+import { STATE_ENTRY } from "./state.ts";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { TodoList } from "./wasm.ts";
+import { runTodo } from "./tool.ts";
+
+interface Fixture {
+  readonly entries: SessionEntry[];
+  readonly session: TodoSession;
+  readonly call: (params: TodoParams) => TodoList;
+}
+
+/**
+ * Creates a branch-backed caller using the real tool and WASM core.
+ * @param {readonly unknown[]} snapshots Existing stored snapshots.
+ * @returns {Fixture} The tool caller and Pi append seam.
+ */
+const first = 0,
+  second = 1,
+  third = 2,
+  last = -1,
+  fixture = (snapshots: readonly unknown[] = []): Fixture => {
+    const entries = snapshots.map((data): SessionEntry => ({
+        customType: STATE_ENTRY,
+        data,
+        id: crypto.randomUUID(),
+        parentId: null,
+        timestamp: "2026-10-20T00:00:00Z",
+        type: "custom",
+      })),
+      session: TodoSession = {
+        append: (customType, data): void => {
+          entries.push({
+            customType,
+            data,
+            id: crypto.randomUUID(),
+            parentId: entries.at(last)?.id ?? null,
+            timestamp: "2026-10-20T00:00:00Z",
+            type: "custom",
+          });
+        },
+        branch: () => entries,
+        sessionId: "test-session",
+      };
+    return { call: (params) => runTodo(params, session).details, entries, session };
+  },
+  /**
+   * A complete self-assigned contract for deterministic behavior tests.
+   * @returns {NonNullable<TodoParams["contract"]>} Authored contract fields.
+   */
+  contract = (): NonNullable<TodoParams["contract"]> => ({
+    acceptance: {
+      argv: ["moon", "run", "todo-core:test"],
+      cwd: ".",
+      expected: "passes",
+      kind: "command",
+    },
+    assignment: { kind: "self" },
+    deliverable: "Executable task contracts",
+    dependsOn: [],
+    scope: { generates: [], owns: ["src/"], reads: ["README.md"], repositoryId: "oisinpi" },
+  }),
+  /**
+   * Returns the runtime ID from the first root in a tool result.
+   * @param {TodoList} list Real tool result.
+   * @returns {string} Runtime ID.
+   */
+  firstId = (list: TodoList): string => {
+    const id = list.tasks.at(first)?.unit?.reference.unitId;
+    if (id === undefined) {
+      throw new Error("Expected a runtime unit ID");
+    }
+    return id;
+  },
+  /**
+   * Requires a root identity at a known fixture position.
+   * @param {TodoList} list Tool result.
+   * @param {number} index Root position.
+   * @returns {string} Runtime ID.
+   */
+  rootId = (list: TodoList, index: number): string => {
+    const id = list.tasks.at(index)?.unit?.reference.unitId;
+    if (id === undefined) {
+      throw new Error("Expected root identity");
+    }
+    return id;
+  },
+  /**
+   * Requires a child identity from the first outcome.
+   * @param {TodoList} list Tool result.
+   * @param {number} index Child position.
+   * @returns {string} Runtime ID.
+   */
+  childId = (list: TodoList, index: number): string => {
+    const id = list.tasks.at(first)?.subtasks?.at(index)?.unit?.reference.unitId;
+    if (id === undefined) {
+      throw new Error("Expected child identity");
+    }
+    return id;
+  };
+
+export { childId, contract, first, firstId, fixture, last, rootId, second, third };
+export type { Fixture };

package/node_modules/@oisin-ee/pi-todo/src/display.ts

@@ -41,8 +41,14 @@ const emptyCount = 0,
       active = list.tasks.flatMap((task) => [
         ...(task.status === "in_progress" ? [task.content] : []),
         ...(task.subtasks ?? [])
-          .filter((child: Readonly<Subtask>) => child.status === "in_progress")
-          .map((child: Readonly<Subtask>) => `${task.content} → ${child.content}`),
+          .filter(
+            (child: Readonly<Pick<Subtask, "content" | "status">>) =>
+              child.status === "in_progress",
+          )
+          .map(
+            (child: Readonly<Pick<Subtask, "content" | "status">>) =>
+              `${task.content} → ${child.content}`,
+          ),
       ]),
       current =
         active.length > emptyCount

package/node_modules/@oisin-ee/pi-todo/src/gate.ts

@@ -0,0 +1,79 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TaskProvider } from "./provider.ts";
+import { ownsTodo } from "./lifecycle.ts";
+
+/** Exact structured reads and workflow controls, never command-text inference. */
+const controls = new Set([
+    "ask",
+    "codemode",
+    "interview",
+    "todo",
+    "tool_search",
+    "read",
+    "ls",
+    "find",
+    "grep",
+    "hypa_read",
+    "hypa_ls",
+    "hypa_find",
+    "hypa_grep",
+    "web_search",
+    "web_fetch",
+    "lsp_diagnostics",
+    "ctx_search",
+    "ctx_stats",
+    "mcp__codebase_memory__search_graph",
+    "mcp__codebase_memory__get_code_snippet",
+    "mcp__codebase_memory__trace_path",
+    "mcp__codebase_memory__detect_changes",
+    "hindsight_search_knowledge_pages",
+    "hindsight_list_knowledge_pages",
+    "hindsight_read_knowledge_page",
+    "hindsight_reflect",
+    "hindsight_sync_status",
+    "hindsight_diagnose",
+    "hindsight_capture_initiative",
+    "mcp__dogsled__spawn",
+    "mcp__dogsled__send",
+    "mcp__dogsled__cancel",
+    "mcp__dogsled__close",
+    "mcp__dogsled__stop",
+    "mcp__dogsled__read",
+    "mcp__dogsled__status",
+    "mcp__dogsled__inbox",
+  ]),
+  /**
+   * Checks actual calls and leases execution-bearing calls.
+   * @param {Readonly<ExtensionAPI>} pi Runtime hooks and metadata.
+   * @param {Readonly<TaskProvider>} provider Task state and leases.
+   */
+  registerGate = (
+    pi: Readonly<Pick<ExtensionAPI, "on" | "getAllTools">>,
+    provider: Readonly<TaskProvider>,
+  ): void => {
+    pi.on("tool_call", (event: Readonly<{ toolName: string; toolCallId: string }>, ctx) => {
+      if (!ownsTodo(pi)) {
+        return { block: false };
+      }
+      provider.context(ctx);
+      if (controls.has(event.toolName)) {
+        return { block: false };
+      }
+      const active = provider.capability().active();
+      if (!active.ok || active.value === null) {
+        return {
+          block: true,
+          reason: active.ok
+            ? "Start a complete self-assigned leaf with todo before shell, code, mutation, or unknown tools."
+            : active.error.message,
+        };
+      }
+      provider.lease(event.toolCallId, active.value.ref);
+      return { block: false };
+    });
+    pi.on("tool_execution_end", (event: Readonly<{ toolCallId: string }>) => {
+      provider.release(event.toolCallId);
+    });
+  };
+
+export { registerGate };