@exaudeus/workrail 3.16.0 → 3.18.0

package/dist/application/services/validation-engine.js

@@ -685,24 +685,24 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
                 issues.push(`${stepLabel}: assessmentConsequences must not be empty when declared`);
                 return;
             }
-            if (!step.assessmentRefs || step.assessmentRefs.length !== 1) {
-                issues.push(`${stepLabel}: assessmentConsequences require exactly one assessmentRef on the same step`);
-                suggestions.push(`Add exactly one assessmentRef to ${stepLabel} before declaring assessmentConsequences`);
+            if (!step.assessmentRefs || step.assessmentRefs.length === 0) {
+                issues.push(`${stepLabel}: assessmentConsequences require at least one assessmentRef on the same step`);
+                suggestions.push(`Add at least one assessmentRef to ${stepLabel} before declaring assessmentConsequences`);
                 return;
             }
             if (step.assessmentConsequences.length > 1) {
                 issues.push(`${stepLabel}: v1 assessment support allows exactly one assessment consequence per step`);
                 suggestions.push(`Reduce assessmentConsequences on ${stepLabel} to a single declaration`);
             }
-            const assessmentDefinition = assessments.find(assessment => assessment.id === step.assessmentRefs?.[0]);
-            if (!assessmentDefinition)
+            const referencedDefinitions = assessments.filter(assessment => step.assessmentRefs.includes(assessment.id));
+            if (referencedDefinitions.length === 0)
                 return;
             for (const consequence of step.assessmentConsequences) {
                 const trigger = consequence.when;
                 const effect = consequence.effect;
-                const allLevels = assessmentDefinition.dimensions.flatMap(d => d.levels);
+                const allLevels = referencedDefinitions.flatMap(def => def.dimensions.flatMap(d => d.levels));
                 if (!allLevels.includes(trigger.anyEqualsLevel)) {
-                    issues.push(`${stepLabel}: assessment consequence anyEqualsLevel '${trigger.anyEqualsLevel}' is not declared in any dimension of assessment '${assessmentDefinition.id}'`);
+                    issues.push(`${stepLabel}: assessment consequence anyEqualsLevel '${trigger.anyEqualsLevel}' is not declared in any dimension of any referenced assessment`);
                     suggestions.push(`Use a level declared in one of the dimensions: ${[...new Set(allLevels)].join(', ')}`);
                 }
                 if (effect.kind !== 'require_followup') {
@@ -776,10 +776,6 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
                     }
                 }
                 validateAssessmentRefsForStep(typedStep, `Step '${step.id}'`);
-                if (typedStep.assessmentRefs !== undefined && typedStep.assessmentRefs.length > 1) {
-                    issues.push(`Step '${step.id}': v1 assessment support allows exactly one assessmentRef per step`);
-                    suggestions.push(`Reduce assessmentRefs on step '${step.id}' to a single assessment id`);
-                }
                 validateAssessmentConsequencesForStep(typedStep, `Step '${step.id}'`);
                 const callValidation = this.validateStepFunctionCalls(step, workflow.definition.functionDefinitions || []);
                 if (!callValidation.valid) {

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

@@ -140,21 +140,19 @@ let WorkflowCompiler = class WorkflowCompiler {
             const assessmentConsequences = typedStep.assessmentConsequences;
             if (!assessmentConsequences)
                 continue;
-            if (!typedStep.assessmentRefs || typedStep.assessmentRefs.length !== 1) {
-                return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares assessmentConsequences but does not declare exactly one assessmentRef`));
-            }
-            const assessment = (workflow.definition.assessments ?? []).find(candidate => candidate.id === typedStep.assessmentRefs?.[0]);
-            if (!assessment) {
-                return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares assessmentConsequences for unknown assessmentRef '${typedStep.assessmentRefs[0]}'`));
+            if (!typedStep.assessmentRefs || typedStep.assessmentRefs.length === 0) {
+                return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares assessmentConsequences but declares no assessmentRefs`));
             }
             if (assessmentConsequences.length > 1) {
                 return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares ${assessmentConsequences.length} assessment consequences. V1 supports exactly one assessment consequence per step.`));
             }
+            const allLevelsAcrossRefs = (workflow.definition.assessments ?? [])
+                .filter(candidate => typedStep.assessmentRefs.includes(candidate.id))
+                .flatMap(assessment => assessment.dimensions.flatMap(d => d.levels));
             for (const consequence of assessmentConsequences) {
                 const trigger = consequence.when;
-                const allLevels = assessment.dimensions.flatMap(d => d.levels);
-                if (!allLevels.includes(trigger.anyEqualsLevel)) {
-                    return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares consequence with anyEqualsLevel '${trigger.anyEqualsLevel}' that is not declared in any dimension of assessment '${assessment.id}'`));
+                if (!allLevelsAcrossRefs.includes(trigger.anyEqualsLevel)) {
+                    return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares consequence with anyEqualsLevel '${trigger.anyEqualsLevel}' that is not declared in any dimension of any referenced assessment`));
                 }
                 if (consequence.effect.kind !== 'require_followup') {
                     return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares unsupported assessment consequence effect '${String(consequence.effect.kind)}'`));
@@ -187,8 +185,8 @@ let WorkflowCompiler = class WorkflowCompiler {
                     }
                 }
                 if (bodyStep.assessmentConsequences) {
-                    if (!bodyStep.assessmentRefs || bodyStep.assessmentRefs.length !== 1) {
-                        return (0, neverthrow_1.err)(error_1.Err.invalidState(`Loop body step '${bodyStep.id}' in loop '${loop.id}' declares assessmentConsequences but does not declare exactly one assessmentRef`));
+                    if (!bodyStep.assessmentRefs || bodyStep.assessmentRefs.length === 0) {
+                        return (0, neverthrow_1.err)(error_1.Err.invalidState(`Loop body step '${bodyStep.id}' in loop '${loop.id}' declares assessmentConsequences but declares no assessmentRefs`));
                     }
                 }
             }

package/dist/application/use-cases/raw-workflow-file-scanner.js

@@ -6,26 +6,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findWorkflowJsonFiles = findWorkflowJsonFiles;
 exports.scanRawWorkflowFiles = scanRawWorkflowFiles;
 const promises_1 = __importDefault(require("fs/promises"));
-const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 async function findWorkflowJsonFiles(baseDirReal) {
     const files = [];
     async function scan(currentDir) {
         const entries = await promises_1.default.readdir(currentDir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path_1.default.join(currentDir, entry.name);
-            if (entry.isDirectory()) {
-                if (entry.name === 'examples') {
-                    continue;
-                }
-                await scan(fullPath);
-            }
-            else if (entry.isFile() && entry.name.endsWith('.json')) {
-                files.push(fullPath);
-            }
+        const jsonFiles = entries.filter((e) => e.isFile() && e.name.endsWith('.json'));
+        const subDirs = entries.filter((e) => e.isDirectory() && e.name !== 'examples');
+        for (const f of jsonFiles) {
+            files.push(path_1.default.join(currentDir, f.name));
         }
+        await Promise.all(subDirs.map((d) => scan(path_1.default.join(currentDir, d.name)).catch((err) => {
+            if (err.code !== 'ENOENT')
+                throw err;
+        })));
     }
     await scan(baseDirReal);
+    files.sort();
     return files;
 }
 async function scanRawWorkflowFiles(baseDirReal) {
@@ -34,7 +31,7 @@ async function scanRawWorkflowFiles(baseDirReal) {
     for (const filePath of allJsonFiles) {
         const relativeFilePath = path_1.default.relative(baseDirReal, filePath);
         try {
-            const stats = (0, fs_1.statSync)(filePath);
+            const stats = await promises_1.default.stat(filePath);
             if (stats.size > 1000000) {
                 results.push({
                     kind: 'unparseable',

package/dist/cli/commands/index.d.ts

@@ -1,4 +1,4 @@
-export { executeInitCommand, type InitCommandDeps } from './init.js';
+export { executeInitCommand, executeInitConfigCommand, type InitCommandDeps, type InitConfigCommandDeps } from './init.js';
 export { executeSourcesCommand, getWorkflowSources, type SourcesCommandDeps, type WorkflowSource } from './sources.js';
 export { executeListCommand, type ListCommandDeps, type ListCommandOptions } from './list.js';
 export { executeValidateCommand, type ValidateCommandDeps } from './validate.js';

package/dist/cli/commands/index.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectWorkflowVersion = exports.migrateWorkflowFile = exports.migrateWorkflow = exports.executeMigrateCommand = exports.executeCleanupCommand = exports.executeStartCommand = exports.executeValidateCommand = exports.executeListCommand = exports.getWorkflowSources = exports.executeSourcesCommand = exports.executeInitCommand = void 0;
+exports.detectWorkflowVersion = exports.migrateWorkflowFile = exports.migrateWorkflow = exports.executeMigrateCommand = exports.executeCleanupCommand = exports.executeStartCommand = exports.executeValidateCommand = exports.executeListCommand = exports.getWorkflowSources = exports.executeSourcesCommand = exports.executeInitConfigCommand = exports.executeInitCommand = void 0;
 var init_js_1 = require("./init.js");
 Object.defineProperty(exports, "executeInitCommand", { enumerable: true, get: function () { return init_js_1.executeInitCommand; } });
+Object.defineProperty(exports, "executeInitConfigCommand", { enumerable: true, get: function () { return init_js_1.executeInitConfigCommand; } });
 var sources_js_1 = require("./sources.js");
 Object.defineProperty(exports, "executeSourcesCommand", { enumerable: true, get: function () { return sources_js_1.executeSourcesCommand; } });
 Object.defineProperty(exports, "getWorkflowSources", { enumerable: true, get: function () { return sources_js_1.getWorkflowSources; } });

package/dist/cli/commands/init.d.ts

@@ -8,4 +8,14 @@ export interface InitCommandDeps {
     readonly homedir: () => string;
     readonly joinPath: (...paths: string[]) => string;
 }
+export interface InitConfigCommandDeps {
+    readonly mkdir: (path: string, options: {
+        recursive: boolean;
+    }) => Promise<string | undefined>;
+    readonly readFile: (path: string) => Promise<string>;
+    readonly writeFile: (path: string, content: string) => Promise<void>;
+    readonly homedir: () => string;
+    readonly joinPath: (...paths: string[]) => string;
+}
 export declare function executeInitCommand(deps: InitCommandDeps): Promise<CliResult>;
+export declare function executeInitConfigCommand(deps: InitConfigCommandDeps): Promise<CliResult>;

package/dist/cli/commands/init.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeInitCommand = executeInitCommand;
+exports.executeInitConfigCommand = executeInitConfigCommand;
 const cli_result_js_1 = require("../types/cli-result.js");
 const SAMPLE_WORKFLOW = {
     id: 'my-custom-workflow',
@@ -47,3 +48,74 @@ async function executeInitCommand(deps) {
         });
     }
 }
+const CONFIG_FILE_TEMPLATE = `{
+  "_comment": "WorkRail configuration file. Uncomment any key to override its default.",
+  "_docs": "Full reference: https://github.com/exaudeus/workrail/blob/main/docs/configuration.md",
+
+  "CACHE_TTL": "300000",
+  "WORKRAIL_WORKFLOWS_DIR": "",
+  "WORKRAIL_DISABLE_UNIFIED_DASHBOARD": "0",
+  "WORKRAIL_DISABLE_AUTO_OPEN": "0",
+  "WORKRAIL_DASHBOARD_PORT": "3456",
+
+  "WORKRAIL_ENABLE_SESSION_TOOLS": "true",
+  "WORKRAIL_ENABLE_EXPERIMENTAL_WORKFLOWS": "false",
+  "WORKRAIL_VERBOSE_LOGGING": "false",
+  "WORKRAIL_ENABLE_AGENTIC_ROUTINES": "true",
+  "WORKRAIL_ENABLE_LEAN_WORKFLOWS": "false",
+  "WORKRAIL_AUTHORITATIVE_DESCRIPTIONS": "false",
+  "WORKRAIL_ENABLE_V2_TOOLS": "true",
+  "WORKRAIL_CLEAN_RESPONSE_FORMAT": "false",
+
+  "WORKFLOW_STORAGE_PATH": "",
+  "WORKFLOW_GIT_REPOS": "",
+  "WORKFLOW_GIT_REPO_URL": "",
+  "WORKFLOW_GIT_REPO_BRANCH": "main",
+  "WORKFLOW_GIT_SYNC_INTERVAL": "60",
+
+  "WORKRAIL_LOG_LEVEL": "SILENT",
+  "WORKRAIL_LOG_FORMAT": "human",
+  "WORKRAIL_DATA_DIR": "",
+  "WORKRAIL_CACHE_DIR": "",
+
+  "WORKRAIL_JSON_RESPONSES": "false"
+}
+`;
+async function executeInitConfigCommand(deps) {
+    const configDir = deps.joinPath(deps.homedir(), '.workrail');
+    const configPath = deps.joinPath(configDir, 'config.json');
+    try {
+        const existing = await deps.readFile(configPath);
+        return (0, cli_result_js_1.success)({
+            message: `Config file already exists at ${configPath}`,
+            details: [
+                'Current contents:',
+                existing,
+                '(File was not modified. Delete it and re-run to regenerate the template.)',
+            ],
+        });
+    }
+    catch {
+    }
+    try {
+        await deps.mkdir(configDir, { recursive: true });
+        await deps.writeFile(configPath, CONFIG_FILE_TEMPLATE);
+        return (0, cli_result_js_1.success)({
+            message: `Config file written to ${configPath}`,
+            details: [
+                'Edit the file to set your preferred defaults.',
+                'Environment variables always override values in this file.',
+                'Sensitive values (tokens, keys) must still be set as environment variables.',
+            ],
+            suggestions: [
+                `Edit: ${configPath}`,
+                'Documentation: workrail docs configuration',
+            ],
+        });
+    }
+    catch (error) {
+        return (0, cli_result_js_1.failure)(`Failed to write config file: ${error instanceof Error ? error.message : String(error)}`, {
+            suggestions: ['Check that you have write permissions to your home directory'],
+        });
+    }
+}

package/dist/cli.js

@@ -26,7 +26,19 @@ program
 program
     .command('init')
     .description('Initialize user workflow directory with sample workflows')
-    .action(async () => {
+    .option('--config', 'Write a ~/.workrail/config.json template instead of initializing workflows')
+    .action(async (options) => {
+    if (options.config) {
+        const result = await (0, index_js_1.executeInitConfigCommand)({
+            mkdir: (p, opts) => fs_1.default.promises.mkdir(p, opts),
+            readFile: (p) => fs_1.default.promises.readFile(p, 'utf-8'),
+            writeFile: (p, content) => fs_1.default.promises.writeFile(p, content, 'utf-8'),
+            homedir: os_1.default.homedir,
+            joinPath: path_1.default.join,
+        });
+        (0, interpret_result_js_1.interpretCliResultWithoutDI)(result);
+        return;
+    }
     const result = await (0, index_js_1.executeInitCommand)({
         mkdir: (p, opts) => fs_1.default.promises.mkdir(p, opts),
         readdir: (p) => fs_1.default.promises.readdir(p),

package/dist/config/config-file.d.ts

@@ -0,0 +1,8 @@
+import type { Result } from '../runtime/result.js';
+export type ConfigFileError = {
+    readonly _tag: 'ConfigFileError';
+    readonly message: string;
+    readonly cause?: unknown;
+};
+export declare function ensureWorkrailConfigFile(): void;
+export declare function loadWorkrailConfigFile(): Result<Record<string, string>, ConfigFileError>;

package/dist/config/config-file.js

@@ -0,0 +1,141 @@
+"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.ensureWorkrailConfigFile = ensureWorkrailConfigFile;
+exports.loadWorkrailConfigFile = loadWorkrailConfigFile;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const zod_1 = require("zod");
+const result_js_1 = require("../runtime/result.js");
+const ALLOWED_CONFIG_FILE_KEYS = new Set([
+    'CACHE_TTL',
+    'WORKRAIL_WORKFLOWS_DIR',
+    'WORKRAIL_DISABLE_UNIFIED_DASHBOARD',
+    'WORKRAIL_DISABLE_AUTO_OPEN',
+    'WORKRAIL_DASHBOARD_PORT',
+    'WORKRAIL_DEV',
+    'WORKRAIL_ENABLE_SESSION_TOOLS',
+    'WORKRAIL_ENABLE_EXPERIMENTAL_WORKFLOWS',
+    'WORKRAIL_VERBOSE_LOGGING',
+    'WORKRAIL_ENABLE_AGENTIC_ROUTINES',
+    'WORKRAIL_ENABLE_LEAN_WORKFLOWS',
+    'WORKRAIL_AUTHORITATIVE_DESCRIPTIONS',
+    'WORKRAIL_ENABLE_V2_TOOLS',
+    'WORKRAIL_CLEAN_RESPONSE_FORMAT',
+    'WORKFLOW_STORAGE_PATH',
+    'WORKFLOW_GIT_REPOS',
+    'WORKFLOW_GIT_REPO_URL',
+    'WORKFLOW_GIT_REPO_BRANCH',
+    'WORKFLOW_GIT_SYNC_INTERVAL',
+    'WORKRAIL_LOG_LEVEL',
+    'WORKRAIL_LOG_FORMAT',
+    'WORKRAIL_DATA_DIR',
+    'WORKRAIL_CACHE_DIR',
+    'WORKRAIL_JSON_RESPONSES',
+]);
+const ConfigFileSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.string());
+const CONFIG_FILE_TEMPLATE = `{
+  "_comment": "WorkRail configuration. Values here are defaults; process.env always wins.",
+  "_docs": "https://github.com/exaudeus/workrail/blob/main/docs/configuration.md",
+
+  "CACHE_TTL": "300000",
+  "WORKRAIL_ENABLE_SESSION_TOOLS": "true",
+  "WORKRAIL_ENABLE_AGENTIC_ROUTINES": "true",
+  "WORKRAIL_ENABLE_V2_TOOLS": "true",
+  "WORKRAIL_ENABLE_LEAN_WORKFLOWS": "false",
+  "WORKRAIL_AUTHORITATIVE_DESCRIPTIONS": "false",
+  "WORKRAIL_CLEAN_RESPONSE_FORMAT": "false",
+  "WORKRAIL_VERBOSE_LOGGING": "false",
+
+  "WORKFLOW_STORAGE_PATH": "",
+  "WORKFLOW_GIT_REPOS": "",
+
+  "WORKRAIL_LOG_LEVEL": "SILENT",
+  "WORKRAIL_LOG_FORMAT": "human"
+}
+`;
+function ensureWorkrailConfigFile() {
+    if (process.env['VITEST'])
+        return;
+    const configPath = path.join(os.homedir(), '.workrail', 'config.json');
+    try {
+        fs.accessSync(configPath);
+    }
+    catch {
+        try {
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
+            fs.writeFileSync(configPath, CONFIG_FILE_TEMPLATE, 'utf-8');
+        }
+        catch {
+        }
+    }
+}
+function loadWorkrailConfigFile() {
+    const configPath = path.join(os.homedir(), '.workrail', 'config.json');
+    let rawContent;
+    try {
+        rawContent = fs.readFileSync(configPath, 'utf-8');
+    }
+    catch (e) {
+        const code = e.code;
+        if (code !== 'ENOENT') {
+            console.warn(`[WorkRail] Could not read config file at ${configPath}: ${e.message}`);
+        }
+        return (0, result_js_1.ok)({});
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawContent);
+    }
+    catch {
+        console.warn(`[WorkRail] config file at ${configPath} contains invalid JSON -- ignoring it. Fix or regenerate with "workrail init --config".`);
+        return (0, result_js_1.ok)({});
+    }
+    const result = ConfigFileSchema.safeParse(parsed);
+    if (!result.success) {
+        console.warn(`[WorkRail] config file at ${configPath} has an unexpected shape -- ignoring it. Expected a flat JSON object with string values.`);
+        return (0, result_js_1.ok)({});
+    }
+    const validated = {};
+    for (const [key, value] of Object.entries(result.data)) {
+        if (!ALLOWED_CONFIG_FILE_KEYS.has(key)) {
+            console.warn(`[WorkRail] config file: unknown key "${key}" -- ignored. See "workrail init --config" for supported keys.`);
+            continue;
+        }
+        validated[key] = value;
+    }
+    return (0, result_js_1.ok)(validated);
+}

package/dist/config/feature-flags.js

@@ -77,6 +77,14 @@ exports.FEATURE_FLAG_DEFINITIONS = [
         since: '0.11.0',
         stable: false,
     },
+    {
+        key: 'devMode',
+        envVar: 'WORKRAIL_DEV',
+        defaultValue: false,
+        description: 'Enable development features: staleness visibility for all workflow categories, structured tool-call timing on stderr, and /api/v2/perf/tool-calls endpoint',
+        since: '0.11.0',
+        stable: false,
+    },
 ];
 function parseBoolean(value, defaultValue) {
     if (value === undefined) {