@evoclock/pi-agentic-driver 0.8.0 → 0.8.2

package/extensions/task-board.ts

@@ -1,15 +1,14 @@
 // SPDX-FileCopyrightText: 2026 Julen Gamboa <j.a.r.gamboa@gmail.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-// BOARD-1 provider extension (§5 reversibility): the board surface registers
-// only when a real board file is observed in the workspace. No board file,
-// no behavior change and no new tool.
+// BOARD-1 provider extension. Both tools register at startup; the board is
+// resolved per tool call from the calling session's working directory. A
+// workspace with no board file gets a structured board-unavailable result —
+// nothing is created and nothing else changes.
 
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 
-// Documented board locations (design §2): workspace-level Obsidian Kanban
-// Markdown, or vogelkop's simpler TASKS.md shape.
 const BOARD_FILENAMES = ["board.md", "TASKS.md"];
 
 export function resolveBoardPath(cwd) {
@@ -23,9 +22,5 @@ export function resolveBoardPath(cwd) {
 
 export default async function taskBoardPi(pi) {
   const module = await import(new URL("../scripts/enforcement/task_board_core_pi.js", import.meta.url).href);
-  const boardPath = resolveBoardPath(pi?.ctx?.cwd);
-  if (boardPath === null) {
-    return { registered: [], observation: { present: false, boardPath: null } };
-  }
-  return module.registerKanbanBoardTools(pi, { boardPath });
+  return module.registerKanbanBoardTools(pi, { resolveBoardPath });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evoclock/pi-agentic-driver",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Guardrail extensions for Agentic Driver: advisory review, bounded Herdr communication, and guarded worker lifecycle.",
   "type": "module",
   "license": "AGPL-3.0-or-later",

package/scripts/enforcement/task_board_core_pi.js

@@ -988,11 +988,12 @@ export function observeBoardProvider({ boardPath }) {
   return { present, boardPath: present ? boardPath : null };
 }
 
-export function registerKanbanBoardTools(pi, { boardPath } = {}) {
-  const observation = observeBoardProvider({ boardPath });
-  if (!observation.present) return { registered: [], observation };
-  // Additive, fail-closed: registered only behind the observation,
-  // so removing the board file removes the surface (§5).
+export function registerKanbanBoardTools(pi, { resolveBoardPath, boardPath } = {}) {
+  // Tools register unconditionally; the board is resolved per call from the
+  // calling session's working directory (Pi extensions have no ctx at
+  // registration time). A workspace with no board file gets a structured
+  // board-unavailable result per call, so the surface stays reversible (§5):
+  // no board, nothing happens.
   const registered = [];
   if (typeof pi?.registerTool === "function") {
     pi.registerTool({
@@ -1000,25 +1001,25 @@ export function registerKanbanBoardTools(pi, { boardPath } = {}) {
       label: "Kanban Board",
       description: "Read-only view of the validated task board: lanes, flags, priorities, dependencies, and dispatchability. The board is additive and grants no authority; agents read it and act within card states.",
       parameters: { type: "object", additionalProperties: false, properties: {} },
-      async execute() {
-        // F7(b): every tool call re-observes the board. If the board file was
-        // removed after registration, return an observed board-unavailable
-        // result instead of silently serving a stale board. Registration
-        // stays; the surface is gated per call.
-        if (!existsSync(observation.boardPath)) {
+      async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+        // The board is resolved per call from the calling session's working
+        // directory. No board in this workspace: structured board-unavailable,
+        // nothing happens.
+        const resolvedBoardPath = (typeof resolveBoardPath === "function" ? resolveBoardPath(ctx?.cwd) : null) ?? boardPath ?? null;
+        if (resolvedBoardPath === null || !existsSync(resolvedBoardPath)) {
           const value = {
             ok: false,
             nonAuthorizing: true,
             persisted: false,
             boardUnavailable: true,
             cards: [],
-            errors: ["board file is no longer present (board-unavailable)"],
+            errors: ["no board.md or TASKS.md in this workspace (board-unavailable)"],
           };
           return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }], details: value };
         }
         let value;
         try {
-          const markdown = readFileSync(observation.boardPath, "utf8");
+          const markdown = readFileSync(resolvedBoardPath, "utf8");
           const validated = validateBoard(markdown);
           value = validated.ok
             ? { ok: true, nonAuthorizing: true, persisted: false, cards: validated.cards, errors: [] }
@@ -1075,18 +1076,25 @@ export function registerKanbanBoardTools(pi, { boardPath } = {}) {
         },
         required: ["title", "specification", "definitionOfDone", "stoppingPoint", "scopePaths", "authority"],
       },
-      async execute(_toolContext, input) {
-        // F7(b): re-observe the board on every call. If the board file was
-        // removed after registration, return board-unavailable instead of
-        // writing to a stale path.
-        if (!existsSync(observation.boardPath)) {
+      async execute(_toolContext, input, _signal, _onUpdate, ctx) {
+        // Resolve the board per call from the calling session's working
+        // directory. No board here: structured board-unavailable, no write.
+        let resolvedBoardPath = (typeof resolveBoardPath === "function" ? resolveBoardPath(ctx?.cwd) : null) ?? boardPath ?? null;
+        // The write tool bootstraps: a MISSING board file is fine (the writer
+        // creates it fresh under the lock). When the resolver finds no board,
+        // fall back to the canonical board.md in the workspace so the writer
+        // can create it.
+        if (resolvedBoardPath === null && typeof ctx?.cwd === "string" && ctx.cwd !== "") {
+          resolvedBoardPath = join(ctx.cwd, "TASKS.md");
+        }
+        if (resolvedBoardPath === null) {
           const value = {
             ok: false,
             persisted: false,
             boardUnavailable: true,
             code: "board-unavailable",
-            reason: "board file is no longer present (board-unavailable)",
-            errors: ["board file is no longer present (board-unavailable)"],
+            reason: "no board.md or TASKS.md in this workspace (board-unavailable)",
+            errors: ["no board.md or TASKS.md in this workspace (board-unavailable)"],
           };
           return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }], details: value };
         }
@@ -1132,12 +1140,15 @@ export function registerKanbanBoardTools(pi, { boardPath } = {}) {
         let result;
         try {
           result = writeCard({
-            boardPath: observation.boardPath,
+            boardPath: resolvedBoardPath,
             input: writerInput,
             authority: input?.authority,
             registries: {},
             surface: "tasks",
-            requireExistingBoard: true,
+            // No requireExistingBoard here: the write tool bootstraps a
+            // fresh board when none exists (§3.4/§5). Recreation is safe —
+            // the writer builds fresh content only, and every card still
+            // requires a genuine authority record.
           });
         } catch (error) {
           const code = typeof error?.code === "string" ? error.code : "writer-error";
@@ -1179,5 +1190,5 @@ export function registerKanbanBoardTools(pi, { boardPath } = {}) {
     });
     registered.push("agentic_kanban_board_write");
   }
-  return { registered, observation };
+  return { registered };
 }