@exaudeus/workrail 3.16.0 → 3.18.0

package/dist/v2/infra/local/pinned-workflow-store/index.js

@@ -1,6 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalPinnedWorkflowStoreV2 = void 0;
+const nodePath = __importStar(require("node:path"));
 const neverthrow_1 = require("neverthrow");
 const index_js_1 = require("../../../durable-core/schemas/compiled-workflow/index.js");
 const jcs_js_1 = require("../../../durable-core/canonical/jcs.js");
@@ -43,6 +77,21 @@ class LocalPinnedWorkflowStoreV2 {
             return (0, neverthrow_1.okAsync)(validated.data);
         });
     }
+    list() {
+        const dir = this.dataDir.pinnedWorkflowsDir();
+        return this.fs.readdir(dir)
+            .orElse((e) => {
+            if (e.code === 'FS_NOT_FOUND')
+                return (0, neverthrow_1.okAsync)([]);
+            return (0, neverthrow_1.errAsync)(mapFsToStoreError(e));
+        })
+            .map((entries) => entries
+            .filter((name) => name.endsWith('.json') && !name.endsWith('.tmp'))
+            .map((name) => nodePath.basename(name, '.json')));
+    }
+    prune(_olderThanMs) {
+        return (0, neverthrow_1.okAsync)(0);
+    }
     put(workflowHash, compiled) {
         const dir = this.dataDir.pinnedWorkflowsDir();
         const filePath = this.dataDir.pinnedWorkflowPath(workflowHash);

package/dist/v2/infra/local/remembered-roots-store/index.d.ts

@@ -1,11 +1,13 @@
 import type { ResultAsync } from 'neverthrow';
 import type { DataDirPortV2 } from '../../../ports/data-dir.port.js';
 import type { FileSystemPortV2 } from '../../../ports/fs.port.js';
+import type { TimeClockPortV2 } from '../../../ports/time-clock.port.js';
 import type { RememberedRootRecordV2, RememberedRootsStoreError, RememberedRootsStorePortV2 } from '../../../ports/remembered-roots-store.port.js';
 export declare class LocalRememberedRootsStoreV2 implements RememberedRootsStorePortV2 {
     private readonly dataDir;
     private readonly fs;
-    constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2);
+    private readonly clock;
+    constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2, clock: TimeClockPortV2);
     listRoots(): ResultAsync<readonly string[], RememberedRootsStoreError>;
     listRootRecords(): ResultAsync<readonly RememberedRootRecordV2[], RememberedRootsStoreError>;
     rememberRoot(rootPath: string): ResultAsync<void, RememberedRootsStoreError>;

package/dist/v2/infra/local/remembered-roots-store/index.js

@@ -9,6 +9,7 @@ const zod_1 = require("zod");
 const neverthrow_1 = require("neverthrow");
 const jcs_js_1 = require("../../../durable-core/canonical/jcs.js");
 const REMEMBERED_ROOTS_LOCK_RETRY_MS = 250;
+const TTL_30_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
 const RememberedRootRecordSchema = zod_1.z.object({
     path: zod_1.z.string(),
     addedAtMs: zod_1.z.number().int().nonnegative(),
@@ -48,9 +49,10 @@ function normalizeRootRecords(roots) {
     return normalized;
 }
 class LocalRememberedRootsStoreV2 {
-    constructor(dataDir, fs) {
+    constructor(dataDir, fs, clock) {
         this.dataDir = dataDir;
         this.fs = fs;
+        this.clock = clock;
     }
     listRoots() {
         return this.listRootRecords().map((roots) => roots.map((root) => root.path));
@@ -88,7 +90,7 @@ class LocalRememberedRootsStoreV2 {
     }
     rememberRoot(rootPath) {
         const normalizedRoot = path_1.default.resolve(rootPath);
-        const nowMs = Date.now();
+        const nowMs = this.clock.nowMs();
         return this.withLock(() => this.listRootRecords().andThen((roots) => {
             const existing = roots.find((root) => root.path === normalizedRoot);
             const nextRoots = existing
@@ -104,7 +106,8 @@ class LocalRememberedRootsStoreV2 {
                         source: 'explicit_workspace_path',
                     },
                 ];
-            return this.persist(nextRoots);
+            const withEviction = nextRoots.filter((r) => r.lastSeenAtMs >= nowMs - TTL_30_DAYS_MS);
+            return this.persist(withEviction);
         }));
     }
     persist(roots) {

package/dist/v2/infra/local/workspace-anchor/index.js

@@ -44,11 +44,13 @@ class LocalWorkspaceAnchorV2 {
             anchors.push({ key: 'repo_root_hash', value: repoRootHash });
         }
         anchors.push({ key: 'repo_root', value: repoRoot });
-        const branch = await this.gitCommand('git rev-parse --abbrev-ref HEAD', cwd);
+        const [branch, sha] = await Promise.all([
+            this.gitCommand('git rev-parse --abbrev-ref HEAD', cwd),
+            this.gitCommand('git rev-parse HEAD', cwd),
+        ]);
         if (branch && branch !== 'HEAD') {
             anchors.push({ key: 'git_branch', value: branch });
         }
-        const sha = await this.gitCommand('git rev-parse HEAD', cwd);
         if (sha && /^[0-9a-f]{40}$/.test(sha)) {
             anchors.push({ key: 'git_head_sha', value: sha });
         }

package/dist/v2/ports/pinned-workflow-store.port.d.ts

@@ -8,4 +8,6 @@ export type PinnedWorkflowStoreError = {
 export interface PinnedWorkflowStorePortV2 {
     get(workflowHash: WorkflowHash): ResultAsync<CompiledWorkflowSnapshot | null, PinnedWorkflowStoreError>;
     put(workflowHash: WorkflowHash, compiled: CompiledWorkflowSnapshot): ResultAsync<void, PinnedWorkflowStoreError>;
+    list(): ResultAsync<readonly WorkflowHash[], PinnedWorkflowStoreError>;
+    prune(olderThanMs: number): ResultAsync<number, PinnedWorkflowStoreError>;
 }

package/dist/v2/usecases/console-routes.js

@@ -82,13 +82,14 @@ function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuff
         req.on('close', () => { sseClients.delete(res); });
         res.on('close', () => { sseClients.delete(res); });
     });
-    if (dev_mode_js_1.DEV_MODE) {
+    const devMode = (0, dev_mode_js_1.isDevMode)();
+    if (devMode) {
         app.get('/api/v2/perf/tool-calls', (req, res) => {
             const rawLimit = req.query['limit'];
             const limit = typeof rawLimit === 'string' ? parseInt(rawLimit, 10) : undefined;
             const safeLimit = (limit !== undefined && Number.isFinite(limit) && limit > 0) ? limit : undefined;
             const observations = timingRingBuffer ? timingRingBuffer.recent(safeLimit) : [];
-            res.json({ success: true, data: { observations, total: timingRingBuffer?.size ?? 0, devMode: dev_mode_js_1.DEV_MODE } });
+            res.json({ success: true, data: { observations, total: timingRingBuffer?.size ?? 0, devMode } });
         });
     }
     app.get('/api/v2/sessions', async (_req, res) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "3.16.0",
+  "version": "3.18.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {

package/spec/authoring-spec.json

@@ -998,11 +998,11 @@
             "step.assessmentRefs",
             "step.assessmentConsequences"
           ],
-          "rule": "V1 supports exactly one assessmentRef per step and at most one assessmentConsequences entry per step. Use anyEqualsLevel as the trigger -- the engine checks all submitted dimensions and fires if any equals that level.",
-          "why": "anyEqualsLevel is the only trigger form. It works for both single-dimension and multi-dimension assessments without requiring the author to choose between two forms.",
+          "rule": "A step may declare one or more assessmentRefs and at most one assessmentConsequences entry. When assessmentConsequences is present, at least one ref is required. Use anyEqualsLevel as the trigger -- the engine checks all submitted dimensions across all referenced assessments and fires if any equals that level.",
+          "why": "Multiple refs allow composing separate orthogonal assessment definitions (e.g. quality-gate + coverage-gate) behind a single blocking consequence, without forcing unrelated dimensions into one monolithic definition.",
           "enforcement": ["schema"],
           "checks": [
-            "No more than one assessmentRefs entry per step.",
+            "At least one assessmentRefs entry when assessmentConsequences is present.",
             "No more than one assessmentConsequences entry per step.",
             "The consequence uses anyEqualsLevel to declare which level blocks -- not a named dimension."
           ],

package/spec/workflow.schema.json

@@ -456,14 +456,13 @@
         },
         "assessmentRefs": {
           "type": "array",
-          "description": "References to workflow-level assessment definitions expected for this step. V1 supports exactly one assessmentRef per step.",
+          "description": "References to workflow-level assessment definitions expected for this step. When assessmentConsequences is present, at least one ref is required; multiple refs are supported and the consequence fires if any dimension across any referenced assessment equals the trigger level.",
           "items": {
             "type": "string",
             "minLength": 1,
             "maxLength": 64
           },
           "minItems": 1,
-          "maxItems": 1,
           "uniqueItems": true
         },
         "assessmentConsequences": {