@evoclock/pi-agentic-driver 1.1.0 → 1.1.1

package/extensions/task-store-adapter.ts

@@ -7,6 +7,10 @@ import {
 } from "../scripts/enforcement/session_tasks_core_pi.js";
 import { createHash } from "node:crypto";
 
+// Pi discovers every packaged extensions/*.ts file. This helper also needs a
+// harmless default factory so discovery can load it without registering tools.
+export default function taskStoreAdapter() {}
+
 // Match TaskList's branch-first/high-water-mark observation in tasks.ts.
 // The session mirror is a fallback; neither reader changes either source.
 function observeSessionTasks(ctx) {

package/package.json

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

package/scripts/enforcement/herdr_communication_pi.js

@@ -58,7 +58,9 @@ const MAX_PROCESS_OUTPUT_BYTES = 128 * 1024;
 const MAX_FAILURE_DIAGNOSTIC_BYTES = 4 * 1024;
 const MAX_REPORT_BYTES = 32 * 1024;
 const MAX_IDENTITY_FIELD_BYTES = 4 * 1024;
-const MAX_MARKER_HORIZONTAL_WHITESPACE = 128;
+// Herdr pads a standalone marker to the terminal width (observed 206 spaces
+// after the opening marker). Keep a finite cap without rejecting that padding.
+const MAX_MARKER_HORIZONTAL_WHITESPACE = 512;
 const MAX_PROMPT_CONTRACT_ECHO_BYTES = 4 * 1024;
 const MAX_READ_LINES = 400;
 // A valid 32 KiB report can contain more than 400 short lines. A second,
@@ -1060,10 +1062,12 @@ function allMarkerOccurrences(text, standaloneOnly = false, additionalPair = und
         ? text.length
         : (newline > end && text[newline - 1] === "\r" ? newline - 1 : newline);
       const trailing = text.slice(end, trailingEnd);
+      // Herdr's recent-unwrapped snapshot can retain Pi's right-hand box
+      // border after a padded marker, even for a real completed report.
       const horizontalOnly = Buffer.byteLength(leading, "utf8") <= MAX_MARKER_HORIZONTAL_WHITESPACE
         && Buffer.byteLength(trailing, "utf8") <= MAX_MARKER_HORIZONTAL_WHITESPACE
         && /^[ \t]*$/.test(leading)
-        && /^[ \t]*$/.test(trailing);
+        && /^[ \t]*(?:│)?$/.test(trailing);
       const lineEnd = newline < 0 || text[newline] === "\n";
       if (!standaloneOnly || (horizontalOnly && lineEnd)) occurrences.push({ marker, index, end });
       from = end;
@@ -1087,7 +1091,9 @@ function promptContractRange(text, marker, occurrenceIndex, { boundEnd = false }
   if (deliveryTail) end += deliveryTail[0].length;
   if (boundEnd && end > occurrenceIndex) return undefined;
   if (Buffer.byteLength(text.slice(anchor, end), "utf8") > MAX_PROMPT_CONTRACT_ECHO_BYTES) return undefined;
-  if (!/^\s*$/.test(text.slice(markerStart, open)) || !/^\s*$/.test(text.slice(open + marker.open.length, close))) return undefined;
+  // The same box border may appear in the echoed report template. Only
+  // whitespace and that exact border are allowed between its markers.
+  if (!/^[\s│]*$/.test(text.slice(markerStart, open)) || !/^[\s│]*$/.test(text.slice(open + marker.open.length, close))) return undefined;
   const otherMarkers = [...new Set(Object.values(REPORT_MARKERS)
     .flatMap((pair) => [pair.open, pair.close]))]
     .filter((value) => value !== marker.open && value !== marker.close);

package/scripts/enforcement/session_tasks_validate_pi.js

@@ -18,7 +18,7 @@ import {
   promotionIdempotencyKey, findExistingPromotedCard, resolveCallerOrigin, hasTasksCapability,
   TASKS_CAPABILITY_ENV,
 } from "./session_tasks_core_pi.js";
-import { validateBoard } from "./task_board_core_pi.js";
+import { validateBoard, projectionPath, parseBoard, serializeBoard, readClaimsState } from "./task_board_core_pi.js";
 
 function readJsonIfExists(path) {
   if (!existsSync(path)) return null;
@@ -134,6 +134,48 @@ export function validateTasksSetup({
       checks.linkage = { ok: brokenLinks.length === 0, brokenLinks };
       errors.push(...brokenLinks);
     }
+    // Compare parsed semantics against the writer's existing projection format.
+    // A missing projection is a warning only (the writer recreates it on write).
+    const projection = projectionPath(resolvedBoardPath);
+    if (existsSync(projection)) {
+      try {
+        const parsed = parseBoard(readFileSync(projection, "utf8"), { surface: "obsidian" });
+        if (!parsed.ok) {
+          checks.projection = { ok: false, path: projection, reason: "the projection does not parse as an Obsidian board" };
+          errors.push(`projection invalid: ${parsed.errors?.join("; ") ?? "unparseable"}`);
+        } else {
+          const claims = readClaimsState(resolvedBoardPath);
+          if (!claims.ok) {
+            checks.projection = { ok: false, path: projection, reason: `claims state unavailable: ${claims.reason}` };
+            errors.push(`projection ${projection} cannot be verified: ${claims.reason}`);
+          } else {
+            const active = new Map(claims.state.claims.map((claim) => [claim.cardId, claim.role]));
+            const expected = parseBoard(serializeBoard(validated.cards.map((card) =>
+              active.has(card.cardId) ? { ...card, activeClaim: active.get(card.cardId) } : card
+            ), { surface: "obsidian" }), { surface: "obsidian" });
+            // Compare the parsed, writer-promised fields, not Markdown formatting.
+            // Include multiplicity: duplicate IDs cannot disappear into a Set.
+            const fields = ["cardId", "lane", "title", "priority", "done", "flags", "hash",
+              "dependencies", "base", "due", "role", "capabilities", "stoppingPoint",
+              "specHash", "dodHash", "specText", "dodText", "scope", "unchangedPaths",
+              "repositories", "tags", "provenance", "importedId", "authoritySource",
+              "authorityWriterHmac", "description", "activeClaim"];
+            const signature = (cards) => cards.map((card) => fields.map((field) =>
+              field === "activeClaim" ? card.fields?.active ?? null : card[field]
+            )).sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+            const stale = JSON.stringify(signature(expected.cards)) !== JSON.stringify(signature(parsed.cards));
+            checks.projection = { ok: !stale, path: projection, cards: parsed.cards.length, stale };
+            if (stale) errors.push(`projection ${projection} is stale: content does not match the canonical board and claims (recomputed on the next trusted write)`);
+          }
+        }
+      } catch (error) {
+        checks.projection = { ok: false, path: projection, reason: String(error?.message || error).slice(0, 200) };
+        errors.push(`projection ${projection} could not be read`);
+      }
+    } else {
+      checks.projection = { ok: true, path: projection, present: false };
+      warnings.push(`no board.md projection at ${projection} (recomputed on the next trusted write; Obsidian rendering unavailable until then)`);
+    }
   } else {
     checks.board = { ok: false, path: resolvedBoardPath, reason: "no TASKS.md in this workspace" };
     warnings.push("no TASKS.md found for the workspace; promotion is unavailable until a board exists (a write tool call bootstraps one)");

package/skills/tasks/SKILL.md

@@ -120,9 +120,11 @@ reverted by re-installing picc-tasks.
 `node scripts/enforcement/session_tasks_validate_pi.js --repo-root <root>`
 is read-only. It validates session snapshot shape, taskListId resolution,
 promotion metadata, linkage integrity, board availability (canonical
-`TASKS.md` first; `board.md` never), and promotion target configuration.
-Exit 0 only when ready; nonzero with a machine-readable error list
-otherwise. It never mutates state, never writes the board, never promotes.
+`TASKS.md` first; `board.md` never), projection consistency when present,
+and promotion target configuration. A missing `board.md` is a warning;
+a present but stale or mismatched projection is an error. Exit 0 only when
+operational; otherwise return a machine-readable error list. It never
+mutates state, writes the board, or promotes.
 
 ## Out of scope in v1