@exaudeus/workrail 1.8.0 → 1.10.0

package/dist/application/services/compiler/feature-registry.d.ts

@@ -0,0 +1,19 @@
+import type { Result } from 'neverthrow';
+import type { PromptValue } from './prompt-blocks.js';
+export interface FeatureDefinition {
+    readonly id: string;
+    readonly constraints?: readonly PromptValue[];
+    readonly procedure?: readonly PromptValue[];
+    readonly verify?: readonly PromptValue[];
+}
+export type FeatureResolveError = {
+    readonly code: 'UNKNOWN_FEATURE';
+    readonly featureId: string;
+    readonly message: string;
+};
+export interface FeatureRegistry {
+    readonly resolve: (featureId: string) => Result<FeatureDefinition, FeatureResolveError>;
+    readonly has: (featureId: string) => boolean;
+    readonly knownIds: () => readonly string[];
+}
+export declare function createFeatureRegistry(): FeatureRegistry;

package/dist/application/services/compiler/feature-registry.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFeatureRegistry = createFeatureRegistry;
+const neverthrow_1 = require("neverthrow");
+const FEATURE_DEFINITIONS = [
+    {
+        id: 'wr.features.memory_context',
+        constraints: [
+            [
+                { kind: 'ref', refId: 'wr.refs.memory_usage' },
+            ],
+        ],
+    },
+];
+function createFeatureRegistry() {
+    const byId = new Map(FEATURE_DEFINITIONS.map(f => [f.id, f]));
+    const knownIds = FEATURE_DEFINITIONS.map(f => f.id);
+    return {
+        resolve(featureId) {
+            const def = byId.get(featureId);
+            if (!def) {
+                return (0, neverthrow_1.err)({
+                    code: 'UNKNOWN_FEATURE',
+                    featureId,
+                    message: `Unknown feature '${featureId}'. Known features: ${knownIds.join(', ')}`,
+                });
+            }
+            return (0, neverthrow_1.ok)(def);
+        },
+        has(featureId) {
+            return byId.has(featureId);
+        },
+        knownIds() {
+            return knownIds;
+        },
+    };
+}

package/dist/application/services/compiler/ref-registry.d.ts

@@ -0,0 +1,12 @@
+import type { Result } from 'neverthrow';
+export type RefResolveError = {
+    readonly code: 'UNKNOWN_REF';
+    readonly refId: string;
+    readonly message: string;
+};
+export interface RefRegistry {
+    readonly resolve: (refId: string) => Result<string, RefResolveError>;
+    readonly has: (refId: string) => boolean;
+    readonly knownIds: () => readonly string[];
+}
+export declare function createRefRegistry(): RefRegistry;

package/dist/application/services/compiler/ref-registry.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRefRegistry = createRefRegistry;
+const neverthrow_1 = require("neverthrow");
+const REF_CONTENT = {
+    'wr.refs.memory_usage': [
+        'If Memory MCP tools are available (memory_briefing, memory_store, memory_query):',
+        '- Query Memory for relevant prior knowledge about this workspace before beginning work',
+        '- After completing significant work, store key discoveries and decisions',
+        '- Use descriptive topics and titles so future sessions can find them',
+        '- Do not block on Memory failures — it is advisory, not load-bearing',
+    ].join('\n'),
+    'wr.refs.memory_store': [
+        'If Memory MCP tools are available (memory_store):',
+        '- Store the key findings from this phase with a descriptive topic and title',
+        '- Include file paths, decisions made, and rationale',
+        '- Do not block on Memory failures — continue regardless',
+    ].join('\n'),
+    'wr.refs.memory_query': [
+        'If Memory MCP tools are available (memory_briefing, memory_query):',
+        '- Check Memory for prior context relevant to this task',
+        '- Use workspace-scoped queries to find related past work',
+        '- Do not block on Memory failures — proceed without prior context if unavailable',
+    ].join('\n'),
+};
+function createRefRegistry() {
+    const knownIds = Object.keys(REF_CONTENT);
+    return {
+        resolve(refId) {
+            const content = REF_CONTENT[refId];
+            if (content === undefined) {
+                return (0, neverthrow_1.err)({
+                    code: 'UNKNOWN_REF',
+                    refId,
+                    message: `Unknown ref '${refId}'. Known refs: ${knownIds.join(', ')}`,
+                });
+            }
+            return (0, neverthrow_1.ok)(content);
+        },
+        has(refId) {
+            return refId in REF_CONTENT;
+        },
+        knownIds() {
+            return knownIds;
+        },
+    };
+}

package/dist/application/services/compiler/resolve-features.d.ts

@@ -0,0 +1,12 @@
+import type { Result } from 'neverthrow';
+import type { FeatureRegistry, FeatureResolveError } from './feature-registry.js';
+import type { WorkflowStepDefinition, LoopStepDefinition } from '../../../types/workflow-definition.js';
+export type ResolveFeaturesPassError = {
+    readonly code: 'FEATURE_RESOLVE_ERROR';
+    readonly cause: FeatureResolveError;
+} | {
+    readonly code: 'FEATURE_ON_RAW_PROMPT_STEP';
+    readonly stepId: string;
+    readonly message: string;
+};
+export declare function resolveFeaturesPass(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], featureIds: readonly string[], registry: FeatureRegistry): Result<readonly (WorkflowStepDefinition | LoopStepDefinition)[], ResolveFeaturesPassError>;

package/dist/application/services/compiler/resolve-features.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFeaturesPass = resolveFeaturesPass;
+const neverthrow_1 = require("neverthrow");
+const workflow_definition_js_1 = require("../../../types/workflow-definition.js");
+function appendValues(existing, injected) {
+    if (!injected || injected.length === 0)
+        return existing;
+    if (!existing || existing.length === 0)
+        return injected;
+    return [...existing, ...injected];
+}
+function applyFeatureToBlocks(blocks, feature) {
+    return {
+        ...blocks,
+        constraints: appendValues(blocks.constraints, feature.constraints),
+        procedure: appendValues(blocks.procedure, feature.procedure),
+        verify: appendValues(blocks.verify, feature.verify),
+    };
+}
+function applyFeaturesToStep(step, features) {
+    if (!step.promptBlocks || features.length === 0)
+        return step;
+    let blocks = step.promptBlocks;
+    for (const feature of features) {
+        blocks = applyFeatureToBlocks(blocks, feature);
+    }
+    return { ...step, promptBlocks: blocks };
+}
+function resolveFeaturesPass(steps, featureIds, registry) {
+    if (featureIds.length === 0)
+        return (0, neverthrow_1.ok)(steps);
+    const features = [];
+    for (const id of featureIds) {
+        const res = registry.resolve(id);
+        if (res.isErr()) {
+            return (0, neverthrow_1.err)({ code: 'FEATURE_RESOLVE_ERROR', cause: res.error });
+        }
+        features.push(res.value);
+    }
+    const resolved = [];
+    for (const step of steps) {
+        if ((0, workflow_definition_js_1.isLoopStepDefinition)(step)) {
+            const resolvedLoop = applyFeaturesToStep(step, features);
+            if (Array.isArray(step.body)) {
+                const bodyResolved = step.body.map(bodyStep => applyFeaturesToStep(bodyStep, features));
+                resolved.push({
+                    ...step,
+                    ...(resolvedLoop.promptBlocks ? { promptBlocks: resolvedLoop.promptBlocks } : {}),
+                    body: bodyResolved,
+                });
+            }
+            else {
+                resolved.push({
+                    ...step,
+                    ...(resolvedLoop.promptBlocks ? { promptBlocks: resolvedLoop.promptBlocks } : {}),
+                });
+            }
+        }
+        else {
+            resolved.push(applyFeaturesToStep(step, features));
+        }
+    }
+    return (0, neverthrow_1.ok)(resolved);
+}

package/dist/application/services/compiler/resolve-refs.d.ts

@@ -0,0 +1,9 @@
+import type { Result } from 'neverthrow';
+import type { RefRegistry, RefResolveError } from './ref-registry.js';
+import type { WorkflowStepDefinition, LoopStepDefinition } from '../../../types/workflow-definition.js';
+export type ResolveRefsPassError = {
+    readonly code: 'REF_RESOLVE_ERROR';
+    readonly stepId: string;
+    readonly cause: RefResolveError;
+};
+export declare function resolveRefsPass(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], registry: RefRegistry): Result<readonly (WorkflowStepDefinition | LoopStepDefinition)[], ResolveRefsPassError>;

package/dist/application/services/compiler/resolve-refs.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRefsPass = resolveRefsPass;
+const neverthrow_1 = require("neverthrow");
+const workflow_definition_js_1 = require("../../../types/workflow-definition.js");
+function resolvePromptValueRefs(value, registry) {
+    if (typeof value === 'string')
+        return (0, neverthrow_1.ok)(value);
+    const resolved = [];
+    for (const part of value) {
+        switch (part.kind) {
+            case 'text':
+                resolved.push(part);
+                break;
+            case 'ref': {
+                const res = registry.resolve(part.refId);
+                if (res.isErr())
+                    return (0, neverthrow_1.err)(res.error);
+                resolved.push({ kind: 'text', text: res.value });
+                break;
+            }
+        }
+    }
+    return (0, neverthrow_1.ok)(resolved);
+}
+function resolvePromptValuesRefs(values, registry) {
+    const resolved = [];
+    for (const value of values) {
+        const res = resolvePromptValueRefs(value, registry);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        resolved.push(res.value);
+    }
+    return (0, neverthrow_1.ok)(resolved);
+}
+function resolveBlockRefs(blocks, registry) {
+    let result = { ...blocks };
+    if (blocks.goal !== undefined) {
+        const res = resolvePromptValueRefs(blocks.goal, registry);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, goal: res.value };
+    }
+    if (blocks.constraints !== undefined) {
+        const res = resolvePromptValuesRefs(blocks.constraints, registry);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, constraints: res.value };
+    }
+    if (blocks.procedure !== undefined) {
+        const res = resolvePromptValuesRefs(blocks.procedure, registry);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, procedure: res.value };
+    }
+    if (blocks.verify !== undefined) {
+        const res = resolvePromptValuesRefs(blocks.verify, registry);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, verify: res.value };
+    }
+    return (0, neverthrow_1.ok)(result);
+}
+function resolveStepRefs(step, registry) {
+    if (!step.promptBlocks)
+        return (0, neverthrow_1.ok)(step);
+    const res = resolveBlockRefs(step.promptBlocks, registry);
+    if (res.isErr()) {
+        return (0, neverthrow_1.err)({
+            code: 'REF_RESOLVE_ERROR',
+            stepId: step.id,
+            cause: res.error,
+        });
+    }
+    return (0, neverthrow_1.ok)({ ...step, promptBlocks: res.value });
+}
+function resolveRefsPass(steps, registry) {
+    const resolved = [];
+    for (const step of steps) {
+        if ((0, workflow_definition_js_1.isLoopStepDefinition)(step)) {
+            const loopRes = resolveStepRefs(step, registry);
+            if (loopRes.isErr())
+                return (0, neverthrow_1.err)(loopRes.error);
+            if (Array.isArray(step.body)) {
+                const bodyResolved = [];
+                for (const bodyStep of step.body) {
+                    const bodyRes = resolveStepRefs(bodyStep, registry);
+                    if (bodyRes.isErr())
+                        return (0, neverthrow_1.err)(bodyRes.error);
+                    bodyResolved.push(bodyRes.value);
+                }
+                resolved.push({
+                    ...step,
+                    ...(loopRes.value.promptBlocks ? { promptBlocks: loopRes.value.promptBlocks } : {}),
+                    body: bodyResolved,
+                });
+            }
+            else {
+                resolved.push({
+                    ...step,
+                    ...(loopRes.value.promptBlocks ? { promptBlocks: loopRes.value.promptBlocks } : {}),
+                });
+            }
+        }
+        else {
+            const res = resolveStepRefs(step, registry);
+            if (res.isErr())
+                return (0, neverthrow_1.err)(res.error);
+            resolved.push(res.value);
+        }
+    }
+    return (0, neverthrow_1.ok)(resolved);
+}

package/dist/application/services/workflow-compiler.d.ts

@@ -15,6 +15,8 @@ export interface CompiledWorkflow {
     readonly loopBodyStepIds: ReadonlySet<string>;
 }
 export declare class WorkflowCompiler {
+    private readonly refRegistry;
+    private readonly featureRegistry;
     compile(workflow: Workflow): Result<CompiledWorkflow, DomainError>;
     private deriveConditionSource;
     private resolveLoopBody;

package/dist/application/services/workflow-compiler.js

@@ -13,9 +13,30 @@ const index_1 = require("../../v2/durable-core/schemas/artifacts/index");
 const neverthrow_1 = require("neverthrow");
 const error_1 = require("../../domain/execution/error");
 const prompt_blocks_1 = require("./compiler/prompt-blocks");
+const resolve_refs_1 = require("./compiler/resolve-refs");
+const ref_registry_1 = require("./compiler/ref-registry");
+const resolve_features_1 = require("./compiler/resolve-features");
+const feature_registry_1 = require("./compiler/feature-registry");
 let WorkflowCompiler = class WorkflowCompiler {
+    constructor() {
+        this.refRegistry = (0, ref_registry_1.createRefRegistry)();
+        this.featureRegistry = (0, feature_registry_1.createFeatureRegistry)();
+    }
     compile(workflow) {
-        const blocksResult = (0, prompt_blocks_1.resolvePromptBlocksPass)(workflow.definition.steps);
+        const featuresResult = (0, resolve_features_1.resolveFeaturesPass)(workflow.definition.steps, workflow.definition.features ?? [], this.featureRegistry);
+        if (featuresResult.isErr()) {
+            const e = featuresResult.error;
+            const message = e.code === 'FEATURE_RESOLVE_ERROR'
+                ? `Feature error — ${e.cause.message}`
+                : e.message;
+            return (0, neverthrow_1.err)(error_1.Err.invalidState(message));
+        }
+        const refsResult = (0, resolve_refs_1.resolveRefsPass)(featuresResult.value, this.refRegistry);
+        if (refsResult.isErr()) {
+            const e = refsResult.error;
+            return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${e.stepId}': ref resolution error — ${e.cause.message}`));
+        }
+        const blocksResult = (0, prompt_blocks_1.resolvePromptBlocksPass)(refsResult.value);
         if (blocksResult.isErr()) {
             const e = blocksResult.error;
             const message = e.code === 'PROMPT_AND_BLOCKS_BOTH_SET'

package/dist/manifest.json

@@ -1,6 +1,14 @@
 {
   "distDir": "dist",
   "files": {
+    "application/services/compiler/feature-registry.d.ts": {
+      "sha256": "0df999218ba4dac5cf3fad34f3291e2b217b662badef01ee20f1258c4d03d13f",
+      "bytes": 740
+    },
+    "application/services/compiler/feature-registry.js": {
+      "sha256": "0350c0bd6ab92b1f38f58d12e2d2064af4275b34dfabf7e1677df9eb284d8ba4",
+      "bytes": 1124
+    },
     "application/services/compiler/prompt-blocks.d.ts": {
       "sha256": "2f40fd7599bd351584505152e9916fdea60891833d22c774c8ac9955f01ccf66",
       "bytes": 1416
@@ -9,6 +17,30 @@
       "sha256": "8ee0e8f7f23f0b298602b97af71a49eaf4fbdc8e7a2bb588c607c2f36e81ef1a",
       "bytes": 5201
     },
+    "application/services/compiler/ref-registry.d.ts": {
+      "sha256": "b93074634a3a26097b9ed35d72351272c567dff184401a95e9f80ea7ae8724a5",
+      "bytes": 428
+    },
+    "application/services/compiler/ref-registry.js": {
+      "sha256": "075b14ab0efd34df85eb9b564362d2415eacffc13f44f1ba54bdc5e8229a7d2e",
+      "bytes": 2008
+    },
+    "application/services/compiler/resolve-features.d.ts": {
+      "sha256": "bb5d0719f1156fe5fc92464bc828407b7be1b1149e79e70e71669cf54dce4ddc",
+      "bytes": 733
+    },
+    "application/services/compiler/resolve-features.js": {
+      "sha256": "04637806407d1888b8b0d78ee05a92eb08c9bb33f695a3db4ad6373e5666831a",
+      "bytes": 2444
+    },
+    "application/services/compiler/resolve-refs.d.ts": {
+      "sha256": "64ed63007495f8b95baeb5f867a6b6ac39f097ad5976803b2642defa80ed31bf",
+      "bytes": 581
+    },
+    "application/services/compiler/resolve-refs.js": {
+      "sha256": "9f9e2a44cec6dfd6d870a645b38e4faf52e17c9ef3654fd600ebcd9943f532c5",
+      "bytes": 4214
+    },
     "application/services/enhanced-error-service.d.ts": {
       "sha256": "b6fe8fad92717f0962f87aa9c0f88277bf28fe2b5e3cfd7875612ee57eb8c684",
       "bytes": 601
@@ -50,12 +82,12 @@
       "bytes": 31038
     },
     "application/services/workflow-compiler.d.ts": {
-      "sha256": "dc7b1ed75ee4e90f90c35088d5c336a94d782012e5926fd7c939613e483b23fc",
-      "bytes": 990
+      "sha256": "d175afb550035f44e6e86dde5a1cf2a1ba68eeb61d39590e02b355a9f0e19bf3",
+      "bytes": 1062
     },
     "application/services/workflow-compiler.js": {
-      "sha256": "e4b8c0966ba04a87d753ca507fdc2ee5082a66e4fb6d539e4782c8ff8e93ef78",
-      "bytes": 6050
+      "sha256": "7517fe0d70974f770dad82ede863477e0f367a63bb1fde84636eb96596c52dca",
+      "bytes": 7269
     },
     "application/services/workflow-interpreter.d.ts": {
       "sha256": "56b5b5ad06d42096deba9f0abe7642c18a355a1e598749aab1730df4e9847674",
@@ -1066,8 +1098,8 @@
       "bytes": 395
     },
     "types/workflow-definition.d.ts": {
-      "sha256": "cb7d6be7e9aa0d4b7b17323cd167edad2f616b6a8c2149df6c40e4d965e7d9b8",
-      "bytes": 3744
+      "sha256": "d8fa099c4f2939f27a7fef55b4c6e40161a9bd0a82e2c6137de0eb8210982e9c",
+      "bytes": 3787
     },
     "types/workflow-definition.js": {
       "sha256": "e269d62f27b7f37f870183d6b77800b7aa1e22dabc894374bab8f34db049a55b",

package/dist/types/workflow-definition.d.ts

@@ -79,6 +79,7 @@ export interface WorkflowDefinition {
     readonly metaGuidance?: readonly string[];
     readonly functionDefinitions?: readonly FunctionDefinition[];
     readonly recommendedPreferences?: WorkflowRecommendedPreferences;
+    readonly features?: readonly string[];
 }
 export declare function isLoopStepDefinition(step: WorkflowStepDefinition | LoopStepDefinition): step is LoopStepDefinition;
 export declare function isWorkflowStepDefinition(step: WorkflowStepDefinition | LoopStepDefinition): step is WorkflowStepDefinition;

package/package.json

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