@exaudeus/workrail 3.15.0 → 3.17.0

package/dist/mcp/assert-output.d.ts

@@ -0,0 +1,37 @@
+export declare function assertOutput<T>(data: T, check: (data: T) => void): T;
+type BlockerPointer = {
+    readonly kind: 'context_key';
+    readonly key: string;
+} | {
+    readonly kind: 'context_budget';
+} | {
+    readonly kind: 'output_contract';
+    readonly contractRef: string;
+} | {
+    readonly kind: 'capability';
+    readonly capability: string;
+} | {
+    readonly kind: 'assessment_dimension';
+    readonly assessmentId: string;
+    readonly dimensionId: string;
+} | {
+    readonly kind: 'workflow_step';
+    readonly stepId: string;
+};
+type BlockerLike = {
+    readonly code: string;
+    readonly pointer: BlockerPointer;
+};
+type BlockerReportLike = {
+    readonly blockers: readonly BlockerLike[];
+};
+export declare function assertBlockerReportInvariants(report: BlockerReportLike): void;
+type PendingLike = {
+    readonly stepId: string;
+} | null;
+type ContinueTokenHolder = {
+    readonly continueToken?: string | null | undefined;
+    readonly pending: PendingLike;
+};
+export declare function assertContinueTokenPresence(data: ContinueTokenHolder): void;
+export {};

package/dist/mcp/assert-output.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertOutput = assertOutput;
+exports.assertBlockerReportInvariants = assertBlockerReportInvariants;
+exports.assertContinueTokenPresence = assertContinueTokenPresence;
+const dev_mode_js_1 = require("./dev-mode.js");
+function assertOutput(data, check) {
+    if ((0, dev_mode_js_1.isDevMode)()) {
+        check(data);
+    }
+    return data;
+}
+function assertBlockerReportInvariants(report) {
+    const keyFor = (b) => {
+        const p = b.pointer;
+        let ptrStable;
+        switch (p.kind) {
+            case 'context_key':
+                ptrStable = p.key;
+                break;
+            case 'output_contract':
+                ptrStable = p.contractRef;
+                break;
+            case 'capability':
+                ptrStable = p.capability;
+                break;
+            case 'assessment_dimension':
+                ptrStable = `${p.assessmentId}|${p.dimensionId}`;
+                break;
+            case 'workflow_step':
+                ptrStable = p.stepId;
+                break;
+            case 'context_budget':
+                ptrStable = '';
+                break;
+            default: {
+                const _exhaustive = p;
+                ptrStable = String(_exhaustive);
+            }
+        }
+        return `${b.code}|${p.kind}|${String(ptrStable)}`;
+    };
+    for (let i = 1; i < report.blockers.length; i++) {
+        if (keyFor(report.blockers[i - 1]) > keyFor(report.blockers[i])) {
+            throw new Error('assertOutput: blockers must be deterministically sorted by composite key');
+        }
+    }
+}
+function assertContinueTokenPresence(data) {
+    if (data.pending != null && data.continueToken == null) {
+        throw new Error('assertOutput: continueToken is required when a pending step exists');
+    }
+}

package/dist/mcp/boundary-coercion.d.ts

@@ -1,2 +1,3 @@
 import { z } from 'zod';
+export declare function buildCoercionFn(shapeSchema: z.ZodObject<z.ZodRawShape>, aliasMap?: Readonly<Record<string, string>>): (args: unknown) => unknown;
 export declare function coerceJsonStringObjectFields(args: unknown, shapeSchema: z.ZodObject<z.ZodRawShape>, aliasMap?: Readonly<Record<string, string>>): unknown;

package/dist/mcp/boundary-coercion.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCoercionFn = buildCoercionFn;
 exports.coerceJsonStringObjectFields = coerceJsonStringObjectFields;
 const zod_1 = require("zod");
+const schema_introspection_js_1 = require("./validation/schema-introspection.js");
 function unwrapToBaseType(schema) {
     let current = schema;
     for (;;) {
@@ -32,6 +34,48 @@ function tryParseJsonObject(value) {
         return null;
     }
 }
+function buildCoercionFn(shapeSchema, aliasMap) {
+    const shape = (0, schema_introspection_js_1.getCachedShape)(shapeSchema);
+    const objectFields = new Set();
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+        if (expectsObjectValue(fieldSchema)) {
+            objectFields.add(key);
+        }
+    }
+    const aliasesToCoerce = new Set();
+    if (aliasMap) {
+        for (const [alias, canonical] of Object.entries(aliasMap)) {
+            if (objectFields.has(canonical)) {
+                aliasesToCoerce.add(alias);
+            }
+        }
+    }
+    const hasCoercibleFields = objectFields.size > 0 || aliasesToCoerce.size > 0;
+    return (args) => {
+        if (!hasCoercibleFields)
+            return args;
+        if (typeof args !== 'object' || args === null)
+            return args;
+        const input = args;
+        let result = null;
+        const coerceField = (key) => {
+            const value = input[key];
+            if (typeof value !== 'string')
+                return;
+            const parsed = tryParseJsonObject(value);
+            if (parsed === null)
+                return;
+            if (result === null)
+                result = { ...input };
+            result[key] = parsed;
+        };
+        for (const key of objectFields)
+            coerceField(key);
+        for (const alias of aliasesToCoerce)
+            coerceField(alias);
+        return result ?? args;
+    };
+}
 function coerceJsonStringObjectFields(args, shapeSchema, aliasMap) {
     if (typeof args !== 'object' || args === null)
         return args;

package/dist/mcp/dev-mode.d.ts

@@ -0,0 +1,2 @@
+export declare function isDevMode(): boolean;
+export declare const DEV_MODE: boolean;

package/dist/mcp/dev-mode.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_MODE = void 0;
+exports.isDevMode = isDevMode;
+const container_js_1 = require("../di/container.js");
+const tokens_js_1 = require("../di/tokens.js");
+function isDevMode() {
+    try {
+        const flags = container_js_1.container.resolve(tokens_js_1.DI.Infra.FeatureFlags);
+        return flags.isEnabled('devMode');
+    }
+    catch {
+        return process.env['WORKRAIL_DEV'] === '1';
+    }
+}
+exports.DEV_MODE = process.env['WORKRAIL_DEV'] === '1';

package/dist/mcp/handler-factory.d.ts

@@ -2,6 +2,6 @@ import { z } from 'zod';
 import type { ToolContext, ToolResult } from './types.js';
 import type { PreValidateResult } from './validation/workflow-next-prevalidate.js';
 import type { WrappedToolHandler, McpCallToolResult } from './types/workflow-tool-edition.js';
-export declare function toMcpResult<T>(result: ToolResult<T>): McpCallToolResult;
+export declare function toMcpResult<T>(result: ToolResult<T>, ctx?: ToolContext): McpCallToolResult;
 export declare function createHandler<TInput extends z.ZodType, TOutput>(schema: TInput, handler: (input: z.infer<TInput>, ctx: ToolContext) => Promise<ToolResult<TOutput>>, shapeSchema?: z.ZodObject<z.ZodRawShape>, aliasMap?: Readonly<Record<string, string>>): WrappedToolHandler;
 export declare function createValidatingHandler<TInput extends z.ZodType, TOutput>(schema: TInput, preValidate: (args: unknown) => PreValidateResult, handler: (input: z.infer<TInput>, ctx: ToolContext) => Promise<ToolResult<TOutput>>, shapeSchema?: z.ZodObject<z.ZodRawShape>, aliasMap?: Readonly<Record<string, string>>): WrappedToolHandler;

package/dist/mcp/handler-factory.js

@@ -11,11 +11,12 @@ const v2_execution_helpers_js_1 = require("./handlers/v2-execution-helpers.js");
 const v2_response_formatter_js_1 = require("./v2-response-formatter.js");
 const render_envelope_js_1 = require("./render-envelope.js");
 const jsonResponsesOverride = process.env.WORKRAIL_JSON_RESPONSES === 'true';
-function toMcpResult(result) {
+function toMcpResult(result, ctx) {
     switch (result.type) {
         case 'success': {
+            const cleanResponseFormat = ctx?.featureFlags.isEnabled('cleanResponseFormat') ?? false;
             if (!jsonResponsesOverride) {
-                const formatted = (0, v2_response_formatter_js_1.formatV2ExecutionResponse)(result.data) ?? (0, v2_response_formatter_js_1.formatV2ResumeResponse)(result.data);
+                const formatted = (0, v2_response_formatter_js_1.formatV2ExecutionResponse)(result.data, cleanResponseFormat) ?? (0, v2_response_formatter_js_1.formatV2ResumeResponse)(result.data);
                 if (formatted !== null) {
                     const content = [{ type: 'text', text: formatted.primary }];
                     if (formatted.references != null) {
@@ -36,7 +37,7 @@ function toMcpResult(result) {
             return {
                 content: [{
                         type: 'text',
-                        text: JSON.stringify(jsonPayload, null, 2),
+                        text: JSON.stringify(jsonPayload),
                     }],
             };
         }
@@ -49,17 +50,18 @@ function toMcpResult(result) {
                             message: result.message,
                             retry: result.retry,
                             ...(result.details !== undefined ? { details: result.details } : {}),
-                        }, null, 2),
+                        }),
                     }],
                 isError: true,
             };
     }
 }
 function createHandler(schema, handler, shapeSchema, aliasMap) {
+    const coerce = shapeSchema !== undefined
+        ? (0, boundary_coercion_js_1.buildCoercionFn)(shapeSchema, aliasMap)
+        : null;
     return async (args, ctx) => {
-        const normalizedArgs = shapeSchema !== undefined
-            ? (0, boundary_coercion_js_1.coerceJsonStringObjectFields)(args, shapeSchema, aliasMap)
-            : args;
+        const normalizedArgs = coerce !== null ? coerce(args) : args;
         const parseResult = schema.safeParse(normalizedArgs);
         if (!parseResult.success) {
             const introspectionSchema = shapeSchema ?? schema;
@@ -75,22 +77,24 @@ function createHandler(schema, handler, shapeSchema, aliasMap) {
                     message: e.message,
                 })),
                 ...patchedDetails,
-            }));
+            }), ctx);
         }
         try {
-            return toMcpResult(await handler(parseResult.data, ctx));
+            return toMcpResult(await handler(parseResult.data, ctx), ctx);
         }
         catch (err) {
             console.error('[WorkRail] Unhandled exception in tool handler:', err);
-            return toMcpResult((0, types_js_1.errNotRetryable)('INTERNAL_ERROR', 'WorkRail encountered an unexpected error. This is not caused by your input.', { suggestion: (0, v2_execution_helpers_js_1.internalSuggestion)('Retry the call.', 'WorkRail has an internal error.') }));
+            return toMcpResult((0, types_js_1.errNotRetryable)('INTERNAL_ERROR', 'WorkRail encountered an unexpected error. This is not caused by your input.', { suggestion: (0, v2_execution_helpers_js_1.internalSuggestion)('Retry the call.', 'WorkRail has an internal error.') }), ctx);
         }
     };
 }
 function createValidatingHandler(schema, preValidate, handler, shapeSchema, aliasMap) {
+    const coerce = shapeSchema !== undefined
+        ? (0, boundary_coercion_js_1.buildCoercionFn)(shapeSchema, aliasMap)
+        : null;
+    const innerHandler = createHandler(schema, handler, shapeSchema);
     return async (args, ctx) => {
-        const normalizedArgs = shapeSchema !== undefined
-            ? (0, boundary_coercion_js_1.coerceJsonStringObjectFields)(args, shapeSchema, aliasMap)
-            : args;
+        const normalizedArgs = coerce !== null ? coerce(args) : args;
         const pre = preValidate(normalizedArgs);
         if (!pre.ok) {
             const error = pre.error;
@@ -106,10 +110,10 @@ function createValidatingHandler(schema, preValidate, handler, shapeSchema, alia
                     ...error,
                     details: boundedDetails,
                 };
-                return toMcpResult(boundedError);
+                return toMcpResult(boundedError, ctx);
             }
-            return toMcpResult(error);
+            return toMcpResult(error, ctx);
         }
-        return createHandler(schema, handler, shapeSchema, aliasMap)(normalizedArgs, ctx);
+        return innerHandler(normalizedArgs, ctx);
     };
 }

package/dist/mcp/handlers/session.js

@@ -5,7 +5,6 @@ exports.handleUpdateSession = handleUpdateSession;
 exports.handleReadSession = handleReadSession;
 exports.handleOpenDashboard = handleOpenDashboard;
 const types_js_1 = require("../types.js");
-const output_schemas_js_1 = require("../output-schemas.js");
 const SESSION_SCHEMA_OVERVIEW = {
     description: 'Bug Investigation Session Data Structure',
     mainSections: {
@@ -58,13 +57,13 @@ async function handleCreateSession(input, ctx) {
     const session = res.value;
     const baseUrl = httpServer.getBaseUrl();
     const dashboardUrl = baseUrl ? `${baseUrl}?session=${input.sessionId}` : null;
-    const payload = output_schemas_js_1.CreateSessionOutputSchema.parse({
+    const payload = {
         sessionId: session.id,
         workflowId: session.workflowId,
         path: sessionManager.getSessionPath(input.workflowId, input.sessionId),
         dashboardUrl,
         createdAt: session.createdAt,
-    });
+    };
     return (0, types_js_1.success)(payload);
 }
 async function handleUpdateSession(input, ctx) {
@@ -81,7 +80,7 @@ async function handleUpdateSession(input, ctx) {
         }
         return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', res.error.message);
     }
-    const payload = output_schemas_js_1.UpdateSessionOutputSchema.parse({ updatedAt: new Date().toISOString() });
+    const payload = { updatedAt: new Date().toISOString() };
     return (0, types_js_1.success)(payload);
 }
 async function handleReadSession(input, ctx) {
@@ -90,10 +89,10 @@ async function handleReadSession(input, ctx) {
         return guardError;
     const sessionManager = ctx.sessionManager;
     if (input.path === '$schema') {
-        const payload = output_schemas_js_1.ReadSessionSchemaOutputSchema.parse({
+        const payload = {
             query: '$schema',
             schema: SESSION_SCHEMA_OVERVIEW,
-        });
+        };
         return (0, types_js_1.success)(payload);
     }
     const res = await sessionManager.readSession(input.workflowId, input.sessionId, input.path);
@@ -105,10 +104,10 @@ async function handleReadSession(input, ctx) {
         }
         return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', res.error.message);
     }
-    const payload = output_schemas_js_1.ReadSessionOutputSchema.parse({
+    const payload = {
         query: input.path ?? '(full session)',
         data: res.value,
-    });
+    };
     return (0, types_js_1.success)(payload);
 }
 async function handleOpenDashboard(input, ctx) {
@@ -118,7 +117,7 @@ async function handleOpenDashboard(input, ctx) {
     const httpServer = ctx.httpServer;
     try {
         const url = await httpServer.openDashboard(input.sessionId);
-        const payload = output_schemas_js_1.OpenDashboardOutputSchema.parse({ url });
+        const payload = { url };
         return (0, types_js_1.success)(payload);
     }
     catch (err) {

package/dist/mcp/handlers/shared/request-workflow-reader.d.ts

@@ -2,6 +2,7 @@ import type { IWorkflowReader } from '../../../types/storage.js';
 import type { IFeatureFlagProvider } from '../../../config/feature-flags.js';
 import type { RememberedRootsStorePortV2 } from '../../../v2/ports/remembered-roots-store.port.js';
 import type { ManagedSourceRecordV2, ManagedSourceStorePortV2 } from '../../../v2/ports/managed-source-store.port.js';
+export declare function clearWalkCacheForTesting(): void;
 export interface RequestWorkflowReaderOptions {
     readonly featureFlags: IFeatureFlagProvider;
     readonly workspacePath?: string;

package/dist/mcp/handlers/shared/request-workflow-reader.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearWalkCacheForTesting = clearWalkCacheForTesting;
 exports.hasRequestWorkspaceSignal = hasRequestWorkspaceSignal;
 exports.resolveRequestWorkspaceDirectory = resolveRequestWorkspaceDirectory;
 exports.toProjectWorkflowDirectory = toProjectWorkflowDirectory;
@@ -13,6 +14,27 @@ const path_1 = __importDefault(require("path"));
 const url_1 = require("url");
 const enhanced_multi_source_workflow_storage_js_1 = require("../../../infrastructure/storage/enhanced-multi-source-workflow-storage.js");
 const schema_validating_workflow_storage_js_1 = require("../../../infrastructure/storage/schema-validating-workflow-storage.js");
+const with_timeout_js_1 = require("./with-timeout.js");
+const SKIP_DIRS = new Set([
+    '.git', 'node_modules',
+    'build', 'dist', 'out', 'target',
+    '.gradle', '.gradle-cache', '.cache',
+    'DerivedData', 'Pods',
+    'vendor',
+    '__pycache__', '.venv', 'venv',
+    '.next', '.nuxt', '.turbo', '.parcel-cache',
+    '.claude', '.claude-worktrees', '.firebender',
+    'coverage', '.nyc_output',
+]);
+const MAX_WALK_DEPTH = 5;
+const WALK_CACHE_TTL_MS = 300000;
+const walkCache = new Map();
+const walkInFlight = new Map();
+function clearWalkCacheForTesting() {
+    walkCache.clear();
+    walkInFlight.clear();
+}
+const DISCOVERY_TIMEOUT_MS = 10000;
 function hasRequestWorkspaceSignal(options) {
     return Boolean(options.workspacePath) || (options.resolvedRootUris?.length ?? 0) > 0;
 }
@@ -34,18 +56,38 @@ function toProjectWorkflowDirectory(workspaceDirectory) {
         ? workspaceDirectory
         : path_1.default.join(workspaceDirectory, 'workflows');
 }
-async function discoverRootedWorkflowDirectories(roots) {
+function discoverRootedWorkflowDirectories(roots) {
+    const cacheKey = roots.map((r) => path_1.default.resolve(r)).sort().join('\0');
+    const now = Date.now();
+    const cached = walkCache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+        return Promise.resolve(cached.result);
+    }
+    const inFlight = walkInFlight.get(cacheKey);
+    if (inFlight)
+        return inFlight;
+    const promise = _doWalk(cacheKey, roots, now);
+    walkInFlight.set(cacheKey, promise);
+    promise.then(() => walkInFlight.delete(cacheKey), () => walkInFlight.delete(cacheKey));
+    return promise;
+}
+async function _doWalk(cacheKey, roots, now) {
     const discoveredByPath = new Set();
     const discoveredPaths = [];
     const stalePaths = [];
-    for (const root of roots) {
-        const rootPath = path_1.default.resolve(root);
-        const result = await discoverWorkflowDirectoriesUnderRoot(rootPath);
-        if (result.stale) {
+    const resolvedRoots = roots.map((r) => path_1.default.resolve(r));
+    const rootResults = await Promise.allSettled(resolvedRoots.map((rootPath) => discoverWorkflowDirectoriesUnderRoot(rootPath)));
+    for (let i = 0; i < resolvedRoots.length; i++) {
+        const rootPath = resolvedRoots[i];
+        const rootResult = rootResults[i];
+        if (rootResult.status === 'rejected') {
+            throw rootResult.reason;
+        }
+        if (rootResult.value.stale) {
             stalePaths.push(rootPath);
             continue;
         }
-        for (const nextPath of result.discovered) {
+        for (const nextPath of rootResult.value.discovered) {
             const normalizedPath = path_1.default.resolve(nextPath);
             if (discoveredByPath.has(normalizedPath))
                 continue;
@@ -53,13 +95,22 @@ async function discoverRootedWorkflowDirectories(roots) {
             discoveredPaths.push(normalizedPath);
         }
     }
-    return { discovered: discoveredPaths, stale: stalePaths };
+    const result = { discovered: discoveredPaths, stale: stalePaths };
+    walkCache.set(cacheKey, { result, expiresAt: now + WALK_CACHE_TTL_MS });
+    return result;
 }
 async function createWorkflowReaderForRequest(options) {
     const workspaceDirectory = resolveRequestWorkspaceDirectory(options);
     const projectWorkflowDirectory = toProjectWorkflowDirectory(workspaceDirectory);
     const rememberedRoots = await listRememberedRoots(options.rememberedRootsStore);
-    const { discovered: rootedWorkflowDirectories, stale: stalePaths } = await discoverRootedWorkflowDirectories(rememberedRoots);
+    let discoveryResult;
+    try {
+        discoveryResult = await (0, with_timeout_js_1.withTimeout)(discoverRootedWorkflowDirectories(rememberedRoots), DISCOVERY_TIMEOUT_MS, 'workflow_root_discovery');
+    }
+    catch {
+        discoveryResult = { discovered: [], stale: [] };
+    }
+    const { discovered: rootedWorkflowDirectories, stale: stalePaths } = discoveryResult;
     const rootedCustomPaths = rootedWorkflowDirectories.filter((directory) => directory !== projectWorkflowDirectory);
     const { records: allManagedRecords, storeError: managedStoreError } = await listManagedSourceRecords(options.managedSourceStore);
     const envCustomPaths = parseWorkflowStoragePathEnv();
@@ -70,17 +121,30 @@ async function createWorkflowReaderForRequest(options) {
     const additionalManagedPaths = [];
     const activeManagedRecords = [];
     const staleManagedRecords = [];
+    const alreadyCovered = [];
+    const needsStatCheck = [];
     for (const record of allManagedRecords) {
         if (normalizedCustom.has(path_1.default.resolve(record.path))) {
-            activeManagedRecords.push(record);
-            continue;
-        }
-        if (await isDirectory(record.path)) {
-            additionalManagedPaths.push(record.path);
-            activeManagedRecords.push(record);
+            alreadyCovered.push(record);
         }
         else {
-            staleManagedRecords.push(record);
+            needsStatCheck.push(record);
+        }
+    }
+    activeManagedRecords.push(...alreadyCovered);
+    if (needsStatCheck.length > 0) {
+        const statResults = await (0, with_timeout_js_1.withTimeout)(Promise.allSettled(needsStatCheck.map((record) => isDirectory(record.path))), DISCOVERY_TIMEOUT_MS, 'managed_source_stat').catch(() => null);
+        for (let i = 0; i < needsStatCheck.length; i++) {
+            const record = needsStatCheck[i];
+            const result = statResults?.[i];
+            const isDir = result?.status === 'fulfilled' && result.value === true;
+            if (isDir) {
+                additionalManagedPaths.push(record.path);
+                activeManagedRecords.push(record);
+            }
+            else {
+                staleManagedRecords.push(record);
+            }
         }
     }
     const customPaths = [...rootedCustomPaths, ...additionalManagedPaths];
@@ -118,8 +182,8 @@ async function listRememberedRoots(rememberedRootsStore) {
         return [];
     const result = await rememberedRootsStore.listRoots();
     if (result.isErr()) {
-        const error = result.error;
-        throw new Error(`Failed to load remembered workflow roots: ${error.code}: ${error.message}`);
+        console.error(`[workrail] Failed to load remembered workflow roots: ${result.error.code}: ${result.error.message}`);
+        return [];
     }
     return result.value.map((root) => path_1.default.resolve(root));
 }
@@ -136,7 +200,7 @@ async function discoverWorkflowDirectoriesUnderRoot(rootPath) {
     }
     return { discovered: discoveredPaths, stale: false };
 }
-async function walkForRootedWorkflowDirectories(currentDirectory, discoveredPaths) {
+async function walkForRootedWorkflowDirectories(currentDirectory, discoveredPaths, depth = 0) {
     const entries = await promises_1.default.readdir(currentDirectory, { withFileTypes: true });
     const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of sortedEntries) {
@@ -152,14 +216,20 @@ async function walkForRootedWorkflowDirectories(currentDirectory, discoveredPath
             }
             continue;
         }
-        await walkForRootedWorkflowDirectories(entryPath, discoveredPaths).catch((err) => {
+        if (depth >= MAX_WALK_DEPTH) {
+            if (process.env['WORKRAIL_DEV'] === '1') {
+                console.error(`[workrail] walk depth limit (${MAX_WALK_DEPTH}) reached at: ${entryPath}`);
+            }
+            continue;
+        }
+        await walkForRootedWorkflowDirectories(entryPath, discoveredPaths, depth + 1).catch((err) => {
             if (err.code !== 'ENOENT')
                 throw err;
         });
     }
 }
 function shouldSkipDirectory(name) {
-    return name === '.git' || name === 'node_modules';
+    return SKIP_DIRS.has(name);
 }
 async function isDirectory(targetPath) {
     try {

package/dist/mcp/handlers/v2-advance-core/event-builders.d.ts

@@ -10,8 +10,10 @@ import type { V2ContinueWorkflowInput } from '../../v2/tools.js';
 import { type OutputToAppend } from '../../../v2/durable-core/domain/outputs.js';
 import type { InternalError } from '../v2-error-mapping.js';
 import type { AdvanceCorePorts } from './index.js';
+import type { SessionIndex } from '../../../v2/durable-core/session-index.js';
 type BuildAppendPlanArgs = {
     readonly truth: LoadedSessionTruthV2;
+    readonly lockedIndex: SessionIndex;
     readonly sessionId: SessionId;
     readonly runId: RunId;
     readonly currentNodeId: NodeId;

package/dist/mcp/handlers/v2-advance-core/event-builders.js

@@ -11,15 +11,15 @@ const outputs_js_1 = require("../../../v2/durable-core/domain/outputs.js");
 const ack_advance_append_plan_js_1 = require("../../../v2/durable-core/domain/ack-advance-append-plan.js");
 const constants_js_1 = require("../../../v2/durable-core/constants.js");
 function buildAndAppendPlan(args) {
-    const { truth, sessionId, runId, currentNodeId, attemptId, workflowHash, extraEventsToAppend, sessionStore, idFactory, lock } = args;
-    const nextEventIndex = truth.events.length === 0 ? 0 : truth.events[truth.events.length - 1].eventIndex + 1;
+    const { truth, lockedIndex, sessionId, runId, currentNodeId, attemptId, workflowHash, extraEventsToAppend, sessionStore, idFactory, lock } = args;
+    const nextEventIndex = lockedIndex.nextEventIndex;
     const evtAdvanceRecorded = idFactory.mintEventId();
     if (args.kind === 'blocked') {
         const toNodeId = String(idFactory.mintNodeId());
         const evtNodeCreated = idFactory.mintEventId();
         const evtEdgeCreated = idFactory.mintEventId();
         const outputEventIds = (args.outputsToAppend ?? []).map(() => idFactory.mintEventId());
-        const hasChildren = truth.events.some((e) => e.kind === constants_js_1.EVENT_KIND.EDGE_CREATED && e.data.fromNodeId === String(currentNodeId));
+        const hasChildren = lockedIndex.hasChildEdgeByFromNodeId.has(String(currentNodeId));
         const causeKind = hasChildren ? constants_js_1.EDGE_CAUSE.NON_TIP_ADVANCE : constants_js_1.EDGE_CAUSE.INTENTIONAL_FORK;
         const planRes = (0, ack_advance_append_plan_js_1.buildAckAdvanceAppendPlanV1)({
             sessionId: String(sessionId),
@@ -44,12 +44,12 @@ function buildAndAppendPlan(args) {
         });
         if (planRes.isErr())
             return (0, neverthrow_1.errAsync)({ kind: 'invariant_violation', message: planRes.error.message });
-        return sessionStore.append(lock, planRes.value);
+        return sessionStore.append(lock, planRes.value, truth);
     }
     const toNodeId = String(idFactory.mintNodeId());
     const evtNodeCreated = idFactory.mintEventId();
     const evtEdgeCreated = idFactory.mintEventId();
-    const hasChildren = truth.events.some((e) => e.kind === constants_js_1.EVENT_KIND.EDGE_CREATED && e.data.fromNodeId === String(currentNodeId));
+    const hasChildren = lockedIndex.hasChildEdgeByFromNodeId.has(String(currentNodeId));
     const causeKind = hasChildren ? constants_js_1.EDGE_CAUSE.NON_TIP_ADVANCE : constants_js_1.EDGE_CAUSE.INTENTIONAL_FORK;
     const normalizedOutputs = (0, outputs_js_1.normalizeOutputsForAppend)(args.outputsToAppend);
     const outputEventIds = normalizedOutputs.map(() => idFactory.mintEventId());
@@ -76,7 +76,7 @@ function buildAndAppendPlan(args) {
     });
     if (planRes.isErr())
         return (0, neverthrow_1.errAsync)({ kind: 'invariant_violation', message: planRes.error.message });
-    return sessionStore.append(lock, planRes.value);
+    return sessionStore.append(lock, planRes.value, truth);
 }
 function buildNotesOutputs(allowNotesAppend, attemptId, inputOutput) {
     if (!allowNotesAppend || !inputOutput?.notesMarkdown)

package/dist/mcp/handlers/v2-advance-core/index.d.ts

@@ -1,4 +1,5 @@
 import { ResultAsync as RA } from 'neverthrow';
+import type { SessionIndex } from '../../../v2/durable-core/session-index.js';
 import type { ExecutionSnapshotFileV1, EngineStateV1 } from '../../../v2/durable-core/schemas/execution-snapshot/index.js';
 import type { SessionId, RunId, NodeId, WorkflowHash } from '../../../v2/durable-core/ids/index.js';
 import type { AttemptId } from '../../../v2/durable-core/tokens/index.js';
@@ -63,4 +64,5 @@ export declare function executeAdvanceCore(args: {
     readonly lock: WithHealthySessionLock;
     readonly pinnedWorkflow: ReturnType<typeof createWorkflow>;
     readonly ports: AdvanceCorePorts;
+    readonly lockedIndex: SessionIndex;
 }): RA<void, InternalError | SessionEventLogStoreError | SnapshotStoreError>;

package/dist/mcp/handlers/v2-advance-core/index.js

@@ -39,6 +39,7 @@ function executeAdvanceCore(args) {
     }
     const validatedRes = (0, input_validation_js_1.validateAdvanceInputs)({
         truth, runId, currentNodeId, inputContext, inputOutput, pinnedWorkflow, pendingStep,
+        precomputedIndex: args.lockedIndex,
     });
     if (validatedRes.isErr())
         return errAsync(validatedRes.error);
@@ -71,7 +72,7 @@ function executeAdvanceCore(args) {
             const ctx = { truth, sessionId, runId, currentNodeId, attemptId, workflowHash, inputOutput, pinnedWorkflow, engineState, pendingStep };
             const computed = { reasons: effectiveReasons, outputRequirement, validation: evalValidation };
             const portsLocal = { snapshotStore, sessionStore, sha256, idFactory };
-            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, v, lock, ports: portsLocal });
+            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, v, lock, ports: portsLocal, lockedIndex: args.lockedIndex });
         }
         const validation = phase.validation;
         const effectiveValidation = v.assessmentValidation && !v.assessmentValidation.validation.valid
@@ -110,9 +111,9 @@ function executeAdvanceCore(args) {
         const computed = { reasons, outputRequirement, validation: effectiveValidation };
         const ports = { snapshotStore, sessionStore, sha256, idFactory };
         if (shouldBlockNow) {
-            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, v, lock, ports });
+            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, v, lock, ports, lockedIndex: args.lockedIndex });
         }
-        return (0, outcome_success_js_1.buildSuccessOutcome)({ mode, ctx, computed, v, lock, ports });
+        return (0, outcome_success_js_1.buildSuccessOutcome)({ mode, ctx, computed, v, lock, ports, lockedIndex: args.lockedIndex });
     });
 }
 function derivePendingStepForMode(mode, engineState) {

package/dist/mcp/handlers/v2-advance-core/input-validation.d.ts

@@ -9,6 +9,7 @@ import type { AssessmentArtifactV1 } from '../../../v2/durable-core/schemas/arti
 import type { RecordedAssessmentV1 } from '../../../v2/durable-core/domain/assessment-record.js';
 import type { TriggeredAssessmentConsequenceV1 } from './assessment-consequences.js';
 import type { InternalError } from '../v2-error-mapping.js';
+import type { SessionIndex } from '../../../v2/durable-core/session-index.js';
 export interface ValidatedAdvanceInputs {
     readonly pendingStep: {
         readonly stepId: string;
@@ -50,4 +51,5 @@ export declare function validateAdvanceInputs(args: {
             readonly iteration: number;
         }[];
     };
+    readonly precomputedIndex?: SessionIndex;
 }): Result<ValidatedAdvanceInputs, InternalError>;