@infinisys/is-fabric-team 0.1.0 → 0.2.0

package/lib/verdict-pool.mjs

@@ -0,0 +1,177 @@
+/**
+ * Spread the evidence gate's parsing across worker threads.
+ *
+ * One criterion's check is compared with every command line the ledger recorded,
+ * and a ledger has several criteria: the product is what saturates one core
+ * while every conversation waits behind it. The lines are independent, so they
+ * are handed out in batches and the answers are joined back in order.
+ *
+ * The callers are synchronous — they filter evidence while rendering a gate — so
+ * the pool keeps its promises synchronously: the main thread posts each batch,
+ * then waits on a shared counter until the workers have answered. That is the
+ * same shape the cost-meter ledger writer uses, and it keeps the gate code
+ * unchanged apart from the call it makes.
+ *
+ * @module is-fabric-team/lib/verdict-pool
+ */
+
+import { Worker, MessageChannel, receiveMessageOnPort } from 'node:worker_threads';
+import { availableParallelism } from 'node:os';
+
+import { checkRunIn } from './check-run.js';
+
+/** Below this many lines the hand-off costs more than it saves. */
+const MIN_LINES = 64;
+
+/** How long the caller waits before falling back to its own thread. */
+const WAIT_MS = 10_000;
+
+/** How many workers one host keeps. */
+const POOL_SIZE = Math.max(1, Math.min(4, availableParallelism() - 1));
+
+/** How long an idle pool keeps its threads. */
+const IDLE_SHUTDOWN_MS = 60_000;
+
+/** The live pool, created on first use. */
+let pool = null;
+
+/** Stops the pool once its threads have been idle for a minute. */
+let idleTimer = null;
+
+/**
+ * How one command line relates to the check, computed here.
+ *
+ * @param {string} command - recorded command line.
+ * @param {string} check - command text the criterion asks for.
+ * @returns {'attributable' | 'masked' | 'none'} verdict.
+ */
+function verdictInline(command, check) {
+  const verdict = checkRunIn(command, check);
+  if (!verdict.invoked) return 'none';
+  return verdict.attributable ? 'attributable' : 'masked';
+}
+
+/**
+ * Start the pool.
+ *
+ * @returns {{ workers: Worker[], signal: Int32Array, pending: number }} state.
+ */
+function startPool() {
+  const signal = new Int32Array(new SharedArrayBuffer(4));
+  const workers = [];
+  for (let index = 0; index < POOL_SIZE; index += 1) {
+    const worker = new Worker(new URL('./verdict-worker.mjs', import.meta.url), { execArgv: [] });
+    worker.unref();
+    workers.push(worker);
+  }
+  idleTimer ??= setInterval(() => stopPool(), IDLE_SHUTDOWN_MS);
+  idleTimer.unref?.();
+  return { workers, signal, pending: 0 };
+}
+
+/**
+ * Park this thread until every batch has answered.
+ *
+ * A parked thread runs no callbacks, so the answers are read straight off each
+ * port rather than awaited. The wait itself sleeps in short steps: the workers
+ * need the CPU this thread is holding.
+ *
+ * @param {Array<{ port1: MessagePort, verdicts: string[] | null }>} jobs - outstanding batches.
+ * @param {Int32Array} signal - shared word to sleep on.
+ * @param {number} until - wall-clock deadline.
+ * @returns {number} how many batches were still unanswered.
+ */
+function drain(jobs, signal, until) {
+  let pending = jobs.length;
+  while (pending > 0 && Date.now() < until) {
+    for (const job of jobs) {
+      if (job.verdicts !== null) continue;
+      const received = receiveMessageOnPort(job.port1);
+      if (received === undefined) continue;
+      job.verdicts = received.message?.verdicts ?? [];
+      pending -= 1;
+      job.port1.close();
+    }
+    if (pending > 0) Atomics.wait(signal, 0, Atomics.load(signal, 0), 2);
+  }
+  return pending;
+}
+
+/**
+ * Ask the pool for the verdicts of one batch, synchronously.
+ *
+ * The caller cannot yield — it is filtering evidence mid-render — so the work is
+ * cut into slices, posted to the workers, and the answers joined back in order.
+ *
+ * @param {string[]} commands - command lines, in ledger order.
+ * @param {string} check - command text the criterion asks for.
+ * @returns {string[] | null} one verdict per line, or null when the pool could not answer.
+ */
+function verdictsFromPool(commands, check) {
+  if (pool === null) pool = startPool();
+  const size = Math.min(pool.workers.length, Math.max(1, Math.ceil(commands.length / 8)));
+  const slices = Array.from({ length: size }, () => []);
+  commands.forEach((command, index) => {
+    slices[Math.floor((index / commands.length) * size)].push(command);
+  });
+  const jobs = slices
+    .filter((slice) => slice.length > 0)
+    .map((slice, slot) => {
+      const { port1, port2 } = new MessageChannel();
+      pool.workers[slot].postMessage({ id: slot, commands: slice, check, port: port2 }, [port2]);
+      return { slice, port1, verdicts: null };
+    });
+  return joinVerdicts(jobs, commands.length);
+}
+
+/**
+ * Wait for every batch and lay the answers out in the order the caller gave.
+ *
+ * @param {Array<{ slice: string[], port1: MessagePort, verdicts: string[] | null }>} jobs - batches.
+ * @param {number} total - how many lines were submitted.
+ * @returns {string[] | null} one verdict per line, or null on timeout.
+ */
+function joinVerdicts(jobs, total) {
+  const unanswered = drain(jobs, pool.signal, Date.now() + WAIT_MS);
+  if (unanswered > 0) return null;
+  const verdicts = new Array(total);
+  let offset = 0;
+  for (const job of jobs) {
+    for (let position = 0; position < job.slice.length; position += 1) {
+      verdicts[offset + position] = job.verdicts[position] ?? 'none';
+    }
+    offset += job.slice.length;
+  }
+  return verdicts;
+}
+
+/**
+ * The verdicts of every line.
+ *
+ * @param {string[]} commands - command lines, in ledger order.
+ * @param {string} check - command text the criterion asks for.
+ * @returns {string[]} one verdict per line.
+ */
+export function verdictsOf(commands, check) {
+  if (commands.length === 0) return [];
+  if (commands.length < MIN_LINES) return commands.map((command) => verdictInline(command, check));
+  return verdictsFromPool(commands, check) ?? commands.map((command) => verdictInline(command, check));
+}
+
+/**
+ * Drop the pool's threads; the next call starts them again.
+ *
+ * @returns {void}
+ */
+export function stopPool() {
+  if (idleTimer !== null) {
+    clearInterval(idleTimer);
+    idleTimer = null;
+  }
+  if (pool === null) return;
+  for (const worker of pool.workers) void worker.terminate();
+  pool = null;
+}
+
+// The idle timer is started with the pool and stopped with it, so a hot reload
+// that disposes this plugin leaves no interval behind counting down to nothing.

package/lib/verdict-worker.mjs

@@ -0,0 +1,35 @@
+/**
+ * Worker side of the evidence gate: decide how a batch of recorded commands
+ * relates to one criterion's check.
+ *
+ * The main thread splits the ledger's command rows across workers and waits for
+ * the answers, so the gate no longer turns one core into the only core. Nothing
+ * here touches the filesystem or the ledger: it receives text, parses it, and
+ * answers with one verdict per line.
+ *
+ * @module is-fabric-team/lib/verdict-worker
+ */
+
+import { parentPort } from 'node:worker_threads';
+
+import { checkRunIn } from './check-run.js';
+
+/**
+ * How one command line relates to the check.
+ *
+ * @param {string} command - recorded command line.
+ * @param {string} check - command text the criterion asks for.
+ * @returns {'attributable' | 'masked' | 'none'} verdict.
+ */
+function verdictOf(command, check) {
+  const verdict = checkRunIn(command, check);
+  if (!verdict.invoked) return 'none';
+  return verdict.attributable ? 'attributable' : 'masked';
+}
+
+parentPort?.on('message', ({ id, commands, check, port }) => {
+  const verdicts = (commands ?? []).map((command) => verdictOf(command, check));
+  // Answer on the port this batch arrived with when there is one: the caller
+  // parks its thread and polls that port, so `parentPort` would never be read.
+  (port ?? parentPort)?.postMessage({ id, verdicts });
+});

package/lib/watchdog.js

@@ -20,6 +20,7 @@
 import { randomUUID } from 'node:crypto';
 import { TEXT_OUTPUT } from './tool-schema.js';
 import { TeamError } from './team-core.js';
+import { laneStage } from './lanes.js';
 import { staleReviews } from './open-work.js';
 import { expireAttention, openAttention, openAttentions } from './attention.js';
 
@@ -302,6 +303,8 @@ function briefAction({ state, now }) {
       id: entry.id,
       title: entry.title,
       status: entry.status,
+      stage: laneStage(state, entry),
+      decisionId: entry.decisionId ?? null,
       createdAt: entry.createdAt,
     })),
     activeDecision: state.decisions?.find((entry) => entry.id === state.activeDecisionId) ?? null,

package/lib/work-record-gate.js

@@ -348,8 +348,8 @@ export function workRecordBody(state, requirement, options = {}) {
  * @param {object} state - ledger state.
  * @returns {{ project: string, issue: number, ref: string } | undefined} thread.
  */
-export function trackedThread(state) {
-  const tracking = activeRequirement(state)?.tracking;
+export function trackedThread(state, requirement = activeRequirement(state)) {
+  const tracking = requirement?.tracking;
   const project = typeof tracking?.project === 'string' ? tracking.project.trim() : '';
   const issue = Number(tracking?.issue);
   if (project === '' || !Number.isInteger(issue)) return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infinisys/is-fabric-team",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Infinity Fabric AI Team: team collaboration mode, local roster and identities, unanimous voting, GitFox tracking and per-role hard boundaries.",
   "license": "MIT",
   "repository": {
@@ -28,13 +28,14 @@
     "client.js",
     "mode.js",
     "lib/*.js",
+    "lib/*.mjs",
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg"
   ],
   "peerDependencies": {
     "@infinisys/is-settings": "^0.1.0",
-    "@infinisys/is-devops": "^0.1.0"
+    "@infinisys/is-devops": "^0.1.1"
   },
   "dsh": {
     "bundle": {