@exaudeus/workrail 3.8.2 → 3.9.1

package/README.md

@@ -157,6 +157,7 @@ The agent will find the workflow, start at step 1, and proceed systematically.
 - **Lockfile is enforced**: `package-lock.json` is canonical and CI will fail if `npm ci` would modify it. Commit lockfile changes intentionally.
 - **Release authority**: releases are produced by **semantic-release** in GitHub Actions (don’t bump versions/tags locally).
 - **Major releases are approval-gated**: breaking changes become **minor by default** and only become **major** when `WORKRAIL_ALLOW_MAJOR_RELEASE=true`.
+- **Release type comes from the commit on `main`**: for squash merges, the PR title / squash commit title controls whether the release is patch, minor, major, or untagged. See `docs/reference/releases.md`.
 - **Preview a release (dry-run)**:
   - **Locally**: `npx semantic-release --dry-run --no-ci`
   - **Locally (major allowed)**: `WORKRAIL_ALLOW_MAJOR_RELEASE=true npx semantic-release --dry-run --no-ci`

package/dist/di/container.js

@@ -223,6 +223,7 @@ async function registerV2Services() {
     });
     const { LocalKeyringV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/keyring/index.js')));
     const { LocalTokenAliasStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/token-alias-store/index.js')));
+    const { LocalRememberedRootsStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/remembered-roots-store/index.js')));
     const { LocalSessionEventLogStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/session-store/index.js')));
     const { LocalSnapshotStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/snapshot-store/index.js')));
     const { LocalPinnedWorkflowStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/pinned-workflow-store/index.js')));
@@ -243,6 +244,13 @@ async function registerV2Services() {
             return new LocalTokenAliasStoreV2(dataDir, fs);
         }),
     });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.RememberedRootsStore, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);
+            const fs = c.resolve(tokens_js_1.DI.V2.FileSystem);
+            return new LocalRememberedRootsStoreV2(dataDir, fs);
+        }),
+    });
     tsyringe_1.container.register(tokens_js_1.DI.V2.SessionStore, {
         useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
             const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);

package/dist/di/tokens.d.ts

@@ -39,6 +39,7 @@ export declare const DI: {
         readonly PinnedWorkflowStore: symbol;
         readonly SessionLock: symbol;
         readonly TokenAliasStore: symbol;
+        readonly RememberedRootsStore: symbol;
         readonly ExecutionGate: symbol;
     };
     readonly Runtime: {

package/dist/di/tokens.js

@@ -42,6 +42,7 @@ exports.DI = {
         PinnedWorkflowStore: Symbol('V2.PinnedWorkflowStore'),
         SessionLock: Symbol('V2.SessionLock'),
         TokenAliasStore: Symbol('V2.TokenAliasStore'),
+        RememberedRootsStore: Symbol('V2.RememberedRootsStore'),
         ExecutionGate: Symbol('V2.ExecutionGate'),
     },
     Runtime: {

package/dist/engine/engine-factory.js

@@ -209,6 +209,7 @@ async function createWorkRailEngine(config = {}) {
     };
     const dataDir = container_js_1.container.resolve(tokens_js_1.DI.V2.DataDir);
     const tokenAliasStore = container_js_1.container.resolve(tokens_js_1.DI.V2.TokenAliasStore);
+    const rememberedRootsStore = container_js_1.container.resolve(tokens_js_1.DI.V2.RememberedRootsStore);
     const aliasLoadResult = await tokenAliasStore.loadIndex();
     if (aliasLoadResult.isErr()) {
         console.error(`[engine-factory] Token alias index load warning: ${aliasLoadResult.error.message}`);
@@ -224,6 +225,7 @@ async function createWorkRailEngine(config = {}) {
         idFactory,
         tokenCodecPorts,
         tokenAliasStore,
+        rememberedRootsStore,
         validationPipelineDeps,
         resolvedRootUris: [],
         dataDir,

package/dist/manifest.json

@@ -386,16 +386,16 @@
       "bytes": 565
     },
     "di/container.js": {
-      "sha256": "6ba1b310aee67ac495a873d8102a5f3453592128f41735fd540022eb1032370a",
-      "bytes": 20016
+      "sha256": "adc19624cd812eecaad5b105f8521628dd19117493cd61d5c1ac2fb5ef51f18d",
+      "bytes": 20531
     },
     "di/tokens.d.ts": {
-      "sha256": "15cb26fb2370ad60ff6fc39d1ccd7df133d0cd4088f7a2deceb30d4c00ca8aae",
-      "bytes": 1991
+      "sha256": "258c404372076ed2f6c892daf546cec5da75a371d44acfadd1fa71e2918117a7",
+      "bytes": 2038
     },
     "di/tokens.js": {
-      "sha256": "d41c9cd45ab4a9aea3e39cad8d6969a4e1e1407c862eb5093ebc01580f99b672",
-      "bytes": 2458
+      "sha256": "68f7bb382faa412efc57b8aac618ca92527e3f48d729996a556dd34c0af19f03",
+      "bytes": 2523
     },
     "domain/execution/error.d.ts": {
       "sha256": "2eac85c42ec399a23724f868641eeadd0d196b4d324ee4caaff82a6b46155bd9",
@@ -450,8 +450,8 @@
       "bytes": 213
     },
     "engine/engine-factory.js": {
-      "sha256": "5461827b470642059198115f5248e97463db9bfb012f63971a4c7f69acda5b7c",
-      "bytes": 13841
+      "sha256": "fae2c23b55b51348f85182b47f6b411c9ff71e9eb61f10bca90320b725a8a814",
+      "bytes": 13978
     },
     "engine/index.d.ts": {
       "sha256": "91e12882c565e96a9809fdf43a0dc0a77fdffdfd562aaf43d2e86e6590ed0b16",
@@ -693,13 +693,21 @@
       "sha256": "83c9585400cc7c20cac3691b8771b9ce8cdc508ba7f5d083a96f7ed975aabc05",
       "bytes": 5967
     },
+    "mcp/handlers/shared/remembered-roots.d.ts": {
+      "sha256": "d98e4c6dbce6333248fd2e015efe482aab2882db61855e9b0576d50881bb0ea2",
+      "bytes": 521
+    },
+    "mcp/handlers/shared/remembered-roots.js": {
+      "sha256": "7f6da2812659bda447d91ef9e3c52d79e8874cddb2e8850f92f618aff0ba924a",
+      "bytes": 2785
+    },
     "mcp/handlers/shared/request-workflow-reader.d.ts": {
-      "sha256": "39b3db1251f5db4da36a14a1b3dba76bdd0cefd5b24637e03307901a3994a12b",
-      "bytes": 927
+      "sha256": "610456c2f26108e8903911a2d06083d7bc8cd4da0b0694d29b8b986998ba71d8",
+      "bytes": 1213
     },
     "mcp/handlers/shared/request-workflow-reader.js": {
-      "sha256": "8e67f92fe93883e6620b4564a1c98c5402ac74f002049b8f8f136008778e2152",
-      "bytes": 2297
+      "sha256": "4f92edc5ba378d6a0c069b2a29046de08809adf309790d15a3a6db7ce580d599",
+      "bytes": 5182
     },
     "mcp/handlers/shared/with-timeout.d.ts": {
       "sha256": "31ca3db008cb5cd439e0d1132bc4b29be0900c403c452931e3a24a50e45beb54",
@@ -709,6 +717,14 @@
       "sha256": "43ab43a505817e03817f2c0b4d1d9c4ec3f12bd120978f211dc0d554ab900139",
       "bytes": 405
     },
+    "mcp/handlers/shared/workflow-source-visibility.d.ts": {
+      "sha256": "5a72accff6d5fcddd3b8e908292a42eae4d8f3a86ecd65807fd586d33177ec79",
+      "bytes": 1552
+    },
+    "mcp/handlers/shared/workflow-source-visibility.js": {
+      "sha256": "3b3f02879704d02235360570c6839afe0c5d3b1475ee9c6a614ac9ed75ffe5e9",
+      "bytes": 4451
+    },
     "mcp/handlers/v2-advance-core.d.ts": {
       "sha256": "0a07ea15caf7b0a3123d3b0b44c2b85392d090dd140bf82370fd0e84d1aa5b0e",
       "bytes": 271
@@ -834,8 +850,8 @@
       "bytes": 1437
     },
     "mcp/handlers/v2-execution/index.js": {
-      "sha256": "adb91a7f6ca0a8cbe07c32908019b012dc72365da900dda13cbbec2e76ee22e6",
-      "bytes": 7239
+      "sha256": "628fb84477bea94a0f4b7ae236cd578bd735d101ed2f0a64ac188b088a053e6b",
+      "bytes": 7534
     },
     "mcp/handlers/v2-execution/replay.d.ts": {
       "sha256": "bbf97633d7e47af3574a9690a1976bb474ca49cecc08af1d5c07e90f9868036d",
@@ -850,8 +866,8 @@
       "bytes": 3422
     },
     "mcp/handlers/v2-execution/start.js": {
-      "sha256": "e572eb50c6a0a30aa138620f32b04702727f07ce2570c29022d1027981c4bcef",
-      "bytes": 18496
+      "sha256": "5287dda42c97dde95471ce52df74c2dc5aba9dc8485b01ebde00fef3a8e62e89",
+      "bytes": 18573
     },
     "mcp/handlers/v2-reference-resolver.d.ts": {
       "sha256": "0b1d2640306b6a0c1067ca66bb20e6ec35d291b33dc328a78d5bfa8006394234",
@@ -874,8 +890,8 @@
       "bytes": 471
     },
     "mcp/handlers/v2-resume.js": {
-      "sha256": "536ba5db0c8fedf8a55c63a59eae4da5ad1cc793e4abf137a5ac9536e6514f68",
-      "bytes": 4140
+      "sha256": "bd7b960ca913e7b7d88bae2d9fe2b6c685d0dd1908f7eb0c41d8f41b5a0b0c4e",
+      "bytes": 4424
     },
     "mcp/handlers/v2-state-conversion.d.ts": {
       "sha256": "94bd06904ef58dd210ff17ffb75c2492beea8937eb06d99749e5d860c0e0d96b",
@@ -898,8 +914,8 @@
       "bytes": 396
     },
     "mcp/handlers/v2-workflow.js": {
-      "sha256": "d305d516bd450d409b8658857f7713cfa74299f9ccf85e103057f684fcd7008a",
-      "bytes": 7185
+      "sha256": "b682d6ae85795519ba09c7aa00b517e7f4c3c7263e4fccd98c8b32182c1c0729",
+      "bytes": 9612
     },
     "mcp/handlers/v2-workspace-resolution.d.ts": {
       "sha256": "dd4de57b4918ebe749cf8c1df70c02bf1effc50932634bae60db53c9a157e872",
@@ -926,12 +942,12 @@
       "bytes": 7991
     },
     "mcp/output-schemas.d.ts": {
-      "sha256": "191d696fd1c8d7dc8f1908c903f84117ceaed6c0aa323fb7606dd3566d739689",
-      "bytes": 53246
+      "sha256": "37e72221eb151903529bc2203f05d0504584980c441086397a1a00f72d910501",
+      "bytes": 68013
     },
     "mcp/output-schemas.js": {
-      "sha256": "28aa9b75ef6c21522b458bd4d05c55e28673510356f8f7e56eb1304544d35132",
-      "bytes": 14384
+      "sha256": "f390f2c853580c63dbaa204354dd2199f282e47c0bcd162d2accf3ab27d7ec04",
+      "bytes": 15326
     },
     "mcp/render-envelope.d.ts": {
       "sha256": "22e83e1aba52968a7136cf289125a217b5f462a5a66a1eebe4669006e3326fdb",
@@ -954,8 +970,8 @@
       "bytes": 960
     },
     "mcp/server.js": {
-      "sha256": "9689ba068eaac9f36f328fa5429b5abe84bb8bd0062f0a59b60dc361dea09cd2",
-      "bytes": 11677
+      "sha256": "f1240cddafaa9b4a83a5e7e6b7176d1c628a63a92868626e420e5b44bc52e94a",
+      "bytes": 11830
     },
     "mcp/step-content-envelope.d.ts": {
       "sha256": "19bd63c4d4de1d5d93393d346625d28ffd1bebdc320d4ba4e694cb740ec97d3b",
@@ -978,8 +994,8 @@
       "bytes": 132
     },
     "mcp/tool-descriptions.js": {
-      "sha256": "c1a517158ca5562ece07da0ebcb244bd275e4556518b2b8861f24c549d22c1cc",
-      "bytes": 9579
+      "sha256": "5cd28a9bd851e64f2063743506d0a33c787803d1738141b23f557aa1e3240fff",
+      "bytes": 9921
     },
     "mcp/tool-factory.d.ts": {
       "sha256": "0fe3c6b863b2d7aef0c3d659ff54f3a9ee8a0a3c2005b6565d2f8ad517bc7211",
@@ -1038,8 +1054,8 @@
       "bytes": 747
     },
     "mcp/types.d.ts": {
-      "sha256": "4c53a0e1e9e34e1bc8be2f04730316f4f0623905b3d5c6dc72170b76ca51a0fa",
-      "bytes": 4792
+      "sha256": "e9677621e0a54c1756e854837b80fe7bd8da58d056aef2db8ab906e817f99b1e",
+      "bytes": 4950
     },
     "mcp/types.js": {
       "sha256": "d10c4070e4c3454d80f0fa9cdc0e978c69c53c13fd09baa8710fcd802fed8926",
@@ -1086,12 +1102,12 @@
       "bytes": 3276
     },
     "mcp/v2/tools.d.ts": {
-      "sha256": "93f1eac69e9d2be8ca354d714fbc64e3cea0e235e6669847677071d83a66450f",
-      "bytes": 7288
+      "sha256": "0a1ffaec8cecdf042f78af53063f9f1288a1c410f59731f189532aa4101e71b9",
+      "bytes": 7206
     },
     "mcp/v2/tools.js": {
-      "sha256": "2b5d12d4de385ca8c530532d12467f113d58a09a808fe075896d2b1c0caa52ae",
-      "bytes": 10071
+      "sha256": "9fb084ad964296bf49e94327aacc8c55857822382f1636278143f8074572bc40",
+      "bytes": 10661
     },
     "mcp/validation/bounded-json.d.ts": {
       "sha256": "82203ac6123d5c6989606c3b5405aaea99ab829c8958835f9ae3ba45b8bc8fd5",
@@ -2046,12 +2062,12 @@
       "bytes": 457
     },
     "v2/infra/local/data-dir/index.d.ts": {
-      "sha256": "fa6e659499c6c742be9f4182c0d705770d2086696956b02d5415b2c5a8c7a44f",
-      "bytes": 847
+      "sha256": "fd652ef0dcf0db64b915c3592b1bd6b6cb272145dc0eed7c3a08bb635ddbe60a",
+      "bytes": 921
     },
     "v2/infra/local/data-dir/index.js": {
-      "sha256": "29dd90a80d199cf16e79169efbc1c06a37ea63254416917cbac8f5e0a81c7f8c",
-      "bytes": 3128
+      "sha256": "79cd5f9ee8ef7f7ca3d3db4868fc5f97b4bc8b002af514916905c412328f58a2",
+      "bytes": 3368
     },
     "v2/infra/local/directory-listing/index.d.ts": {
       "sha256": "3139014cb738db3b0f10beca01a3a4a35b9ab8e72c8889b3bbff204fdbcb6b6c",
@@ -2109,6 +2125,14 @@
       "sha256": "dfacf7ed6ead595872b8523f113f7228f9ca3b7ab1a84700e874db61c6fad066",
       "bytes": 345
     },
+    "v2/infra/local/remembered-roots-store/index.d.ts": {
+      "sha256": "385164a9468d2fe3c4dd74c8363a0b1f003556bfcc7e9bd5e3046bb167a7231d",
+      "bytes": 840
+    },
+    "v2/infra/local/remembered-roots-store/index.js": {
+      "sha256": "9616940b66438ee85ae22fca2267b30072dfb2907abdab0b1e3ce03a5971f814",
+      "bytes": 7198
+    },
     "v2/infra/local/session-lock/index.d.ts": {
       "sha256": "3b381b372da6039df678dfddf377600547e1067cf921cc1b4cdf578e5df0a1bb",
       "bytes": 853
@@ -2206,8 +2230,8 @@
       "bytes": 77
     },
     "v2/ports/data-dir.port.d.ts": {
-      "sha256": "f3b73eb92fa52a657ef54eb9e3c62bdd2a6c265771fc2e23d6526f2ef558cf9c",
-      "bytes": 610
+      "sha256": "f23993e2101651b738c43d7d02178e622b39c32033a36bf06699d6803b244c0e",
+      "bytes": 684
     },
     "v2/ports/data-dir.port.js": {
       "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
@@ -2261,6 +2285,14 @@
       "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
       "bytes": 77
     },
+    "v2/ports/remembered-roots-store.port.d.ts": {
+      "sha256": "e05a1ae31b12d93c6c846cabaa0cf5b7c01a931b23f0c9ddebfdca6bad6e459c",
+      "bytes": 965
+    },
+    "v2/ports/remembered-roots-store.port.js": {
+      "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
+      "bytes": 77
+    },
     "v2/ports/session-event-log-store.port.d.ts": {
       "sha256": "97838c9212ba1f07d779cfe57591bc2dcbad05567aab99ce9714aba12a26ad26",
       "bytes": 2070

package/dist/mcp/handlers/shared/remembered-roots.d.ts

@@ -0,0 +1,4 @@
+import { type ToolError } from '../../types.js';
+import type { RememberedRootRecordV2, RememberedRootsStorePortV2 } from '../../../v2/ports/remembered-roots-store.port.js';
+export declare function rememberExplicitWorkspaceRoot(workspacePath: string | undefined, rememberedRootsStore: RememberedRootsStorePortV2 | undefined): Promise<ToolError | null>;
+export declare function listRememberedRootRecords(rememberedRootsStore: RememberedRootsStorePortV2 | undefined): Promise<readonly RememberedRootRecordV2[] | ToolError>;

package/dist/mcp/handlers/shared/remembered-roots.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rememberExplicitWorkspaceRoot = rememberExplicitWorkspaceRoot;
+exports.listRememberedRootRecords = listRememberedRootRecords;
+const path_1 = __importDefault(require("path"));
+const types_js_1 = require("../../types.js");
+async function rememberExplicitWorkspaceRoot(workspacePath, rememberedRootsStore) {
+    if (!workspacePath || !rememberedRootsStore)
+        return null;
+    if (!path_1.default.isAbsolute(workspacePath))
+        return null;
+    const result = await rememberedRootsStore.rememberRoot(workspacePath);
+    if (result.isErr()) {
+        const error = result.error;
+        if (error.code === 'REMEMBERED_ROOTS_BUSY') {
+            return (0, types_js_1.errRetryAfterMs)('INTERNAL_ERROR', 'WorkRail is temporarily busy updating remembered workflow roots.', error.retry.afterMs, {
+                suggestion: 'Wait a moment and retry this call. Another WorkRail process may be updating remembered workflow roots.',
+            });
+        }
+        return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', `WorkRail could not persist the workspace root for workflow-source setup.`, {
+            suggestion: 'Fix WorkRail local storage access and retry. Check that the ~/.workrail data directory exists and is writable.',
+            details: {
+                workspacePath,
+                rememberedRootsErrorCode: error.code,
+                rememberedRootsErrorMessage: error.message,
+            },
+        });
+    }
+    return null;
+}
+async function listRememberedRootRecords(rememberedRootsStore) {
+    if (!rememberedRootsStore)
+        return [];
+    const result = await rememberedRootsStore.listRootRecords();
+    if (result.isErr()) {
+        const error = result.error;
+        if (error.code === 'REMEMBERED_ROOTS_BUSY') {
+            return (0, types_js_1.errRetryAfterMs)('INTERNAL_ERROR', 'WorkRail is temporarily busy reading remembered workflow roots.', error.retry.afterMs, {
+                suggestion: 'Wait a moment and retry this call. Another WorkRail process may be updating remembered workflow roots.',
+            });
+        }
+        return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', 'WorkRail could not load remembered workflow roots for workflow-source visibility.', {
+            suggestion: 'Fix WorkRail local storage access and retry. Check that the ~/.workrail data directory exists and is writable.',
+            details: {
+                rememberedRootsErrorCode: error.code,
+                rememberedRootsErrorMessage: error.message,
+            },
+        });
+    }
+    return result.value;
+}

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

@@ -1,10 +1,12 @@
 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';
 export interface RequestWorkflowReaderOptions {
     readonly featureFlags: IFeatureFlagProvider;
     readonly workspacePath?: string;
     readonly resolvedRootUris?: readonly string[];
     readonly serverCwd?: string;
+    readonly rememberedRootsStore?: RememberedRootsStorePortV2;
 }
 export declare function hasRequestWorkspaceSignal(options: {
     readonly workspacePath?: string;
@@ -16,4 +18,5 @@ export declare function resolveRequestWorkspaceDirectory(options: {
     readonly serverCwd?: string;
 }): string;
 export declare function toProjectWorkflowDirectory(workspaceDirectory: string): string;
-export declare function createWorkflowReaderForRequest(options: RequestWorkflowReaderOptions): IWorkflowReader;
+export declare function discoverRootedWorkflowDirectories(roots: readonly string[]): Promise<readonly string[]>;
+export declare function createWorkflowReaderForRequest(options: RequestWorkflowReaderOptions): Promise<IWorkflowReader>;

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

@@ -6,7 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasRequestWorkspaceSignal = hasRequestWorkspaceSignal;
 exports.resolveRequestWorkspaceDirectory = resolveRequestWorkspaceDirectory;
 exports.toProjectWorkflowDirectory = toProjectWorkflowDirectory;
+exports.discoverRootedWorkflowDirectories = discoverRootedWorkflowDirectories;
 exports.createWorkflowReaderForRequest = createWorkflowReaderForRequest;
+const promises_1 = __importDefault(require("fs/promises"));
 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");
@@ -32,12 +34,79 @@ function toProjectWorkflowDirectory(workspaceDirectory) {
         ? workspaceDirectory
         : path_1.default.join(workspaceDirectory, 'workflows');
 }
-function createWorkflowReaderForRequest(options) {
+async function discoverRootedWorkflowDirectories(roots) {
+    const discoveredByPath = new Set();
+    const discoveredPaths = [];
+    for (const root of roots) {
+        const rootPath = path_1.default.resolve(root);
+        const nextPaths = await discoverWorkflowDirectoriesUnderRoot(rootPath);
+        for (const nextPath of nextPaths) {
+            const normalizedPath = path_1.default.resolve(nextPath);
+            if (discoveredByPath.has(normalizedPath))
+                continue;
+            discoveredByPath.add(normalizedPath);
+            discoveredPaths.push(normalizedPath);
+        }
+    }
+    return discoveredPaths;
+}
+async function createWorkflowReaderForRequest(options) {
     const workspaceDirectory = resolveRequestWorkspaceDirectory(options);
     const projectWorkflowDirectory = toProjectWorkflowDirectory(workspaceDirectory);
-    const storage = new enhanced_multi_source_workflow_storage_js_1.EnhancedMultiSourceWorkflowStorage({ projectPath: projectWorkflowDirectory }, options.featureFlags);
+    const rememberedRoots = await listRememberedRoots(options.rememberedRootsStore);
+    const rootedWorkflowDirectories = await discoverRootedWorkflowDirectories(rememberedRoots);
+    const customPaths = rootedWorkflowDirectories.filter((directory) => directory !== projectWorkflowDirectory);
+    const storage = new enhanced_multi_source_workflow_storage_js_1.EnhancedMultiSourceWorkflowStorage({
+        customPaths,
+        projectPath: projectWorkflowDirectory,
+    }, options.featureFlags);
     return new schema_validating_workflow_storage_js_1.SchemaValidatingCompositeWorkflowStorage(storage);
 }
+async function listRememberedRoots(rememberedRootsStore) {
+    if (!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}`);
+    }
+    return result.value.map((root) => path_1.default.resolve(root));
+}
+async function discoverWorkflowDirectoriesUnderRoot(rootPath) {
+    const discoveredPaths = [];
+    await walkForRootedWorkflowDirectories(rootPath, discoveredPaths);
+    return discoveredPaths;
+}
+async function walkForRootedWorkflowDirectories(currentDirectory, discoveredPaths) {
+    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) {
+        if (!entry.isDirectory())
+            continue;
+        const entryPath = path_1.default.join(currentDirectory, entry.name);
+        if (shouldSkipDirectory(entry.name))
+            continue;
+        if (entry.name === '.workrail') {
+            const workflowsDirectory = path_1.default.join(entryPath, 'workflows');
+            if (await isDirectory(workflowsDirectory)) {
+                discoveredPaths.push(path_1.default.resolve(workflowsDirectory));
+            }
+            continue;
+        }
+        await walkForRootedWorkflowDirectories(entryPath, discoveredPaths);
+    }
+}
+function shouldSkipDirectory(name) {
+    return name === '.git' || name === 'node_modules';
+}
+async function isDirectory(targetPath) {
+    try {
+        return (await promises_1.default.stat(targetPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 function fileUriToFsPath(uri) {
     if (!uri.startsWith('file://'))
         return null;

package/dist/mcp/handlers/shared/workflow-source-visibility.d.ts

@@ -0,0 +1,33 @@
+import type { Workflow, WorkflowSourceInfo } from '../../../types/workflow.js';
+import type { IWorkflowReader } from '../../../types/storage.js';
+import type { RememberedRootRecordV2 } from '../../../v2/ports/remembered-roots-store.port.js';
+export interface PublicWorkflowSource {
+    readonly kind: WorkflowSourceInfo['kind'];
+    readonly displayName: string;
+}
+export interface RootedSharingContext {
+    readonly kind: 'remembered_root';
+    readonly rootPath: string;
+    readonly groupLabel: string;
+}
+export type WorkflowVisibilityCategory = 'built_in' | 'personal' | 'legacy_project' | 'rooted_sharing' | 'external';
+export interface WorkflowMigrationGuidance {
+    readonly preferredSource: 'rooted_sharing';
+    readonly currentSource: 'legacy_project';
+    readonly reason: 'legacy_project_precedence';
+    readonly summary: string;
+}
+export interface WorkflowVisibility {
+    readonly category: WorkflowVisibilityCategory;
+    readonly source: PublicWorkflowSource;
+    readonly rootedSharing?: RootedSharingContext;
+    readonly migration?: WorkflowMigrationGuidance;
+}
+export declare function toWorkflowVisibility(workflow: Workflow, rememberedRoots: readonly RememberedRootRecordV2[], options?: {
+    readonly migration?: WorkflowMigrationGuidance;
+}): WorkflowVisibility;
+export declare function detectWorkflowMigrationGuidance(options: {
+    readonly workflow: Workflow;
+    readonly workflowReader: IWorkflowReader;
+    readonly rememberedRoots: readonly RememberedRootRecordV2[];
+}): Promise<WorkflowMigrationGuidance | undefined>;

package/dist/mcp/handlers/shared/workflow-source-visibility.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toWorkflowVisibility = toWorkflowVisibility;
+exports.detectWorkflowMigrationGuidance = detectWorkflowMigrationGuidance;
+const path_1 = __importDefault(require("path"));
+function toWorkflowVisibility(workflow, rememberedRoots, options = {}) {
+    const source = {
+        kind: workflow.source.kind,
+        displayName: workflow.source.kind === 'bundled'
+            ? 'Built-in'
+            : workflow.source.kind === 'user'
+                ? 'User Library'
+                : workflow.source.kind === 'project'
+                    ? 'Project'
+                    : workflow.source.kind === 'custom'
+                        ? workflow.source.label || 'Custom'
+                        : workflow.source.kind === 'git'
+                            ? workflow.source.repositoryUrl
+                            : workflow.source.kind === 'remote'
+                                ? workflow.source.registryUrl
+                                : workflow.source.pluginName,
+    };
+    const rootedSharing = deriveRootedSharingContext(workflow, rememberedRoots);
+    const category = deriveVisibilityCategory(workflow, rootedSharing);
+    return {
+        category,
+        source,
+        ...(rootedSharing ? { rootedSharing } : {}),
+        ...(options.migration ? { migration: options.migration } : {}),
+    };
+}
+async function detectWorkflowMigrationGuidance(options) {
+    const { workflow, workflowReader, rememberedRoots } = options;
+    if (workflow.source.kind !== 'project')
+        return undefined;
+    if (!isCompositeWorkflowReader(workflowReader))
+        return undefined;
+    for (const storage of workflowReader.getStorageInstances()) {
+        if (storage.source.kind !== 'custom')
+            continue;
+        const alternative = await storage.getWorkflowById(workflow.definition.id);
+        if (!alternative)
+            continue;
+        const rootedSharing = deriveRootedSharingContext(alternative, rememberedRoots);
+        if (!rootedSharing)
+            continue;
+        return {
+            preferredSource: 'rooted_sharing',
+            currentSource: 'legacy_project',
+            reason: 'legacy_project_precedence',
+            summary: 'Project-scoped ./workflows currently overrides rooted .workrail/workflows during migration. Prefer rooted sharing for new team-shared workflows.',
+        };
+    }
+    return undefined;
+}
+function isCompositeWorkflowReader(workflowReader) {
+    return (workflowReader.kind === 'composite' &&
+        typeof workflowReader.getStorageInstances === 'function');
+}
+function deriveRootedSharingContext(workflow, rememberedRoots) {
+    if (workflow.source.kind !== 'custom')
+        return undefined;
+    const sourcePath = path_1.default.resolve(workflow.source.directoryPath);
+    for (const record of rememberedRoots) {
+        const rootPath = path_1.default.resolve(record.path);
+        const relative = path_1.default.relative(rootPath, sourcePath);
+        const isUnderRoot = relative.length === 0 ||
+            (!relative.startsWith('..') && !path_1.default.isAbsolute(relative));
+        if (!isUnderRoot)
+            continue;
+        return {
+            kind: 'remembered_root',
+            rootPath,
+            groupLabel: deriveGroupLabel(rootPath, sourcePath),
+        };
+    }
+    return undefined;
+}
+function deriveVisibilityCategory(workflow, rootedSharing) {
+    switch (workflow.source.kind) {
+        case 'bundled':
+            return 'built_in';
+        case 'user':
+            return 'personal';
+        case 'project':
+            return 'legacy_project';
+        case 'custom':
+            return rootedSharing ? 'rooted_sharing' : 'external';
+        case 'git':
+        case 'remote':
+        case 'plugin':
+            return 'external';
+    }
+}
+function deriveGroupLabel(rootPath, sourcePath) {
+    const relative = path_1.default.relative(rootPath, sourcePath);
+    if (!relative || relative === '.workrail/workflows') {
+        return path_1.default.basename(rootPath);
+    }
+    const segments = relative.split(path_1.default.sep).filter(Boolean);
+    const workrailIndex = segments.indexOf('.workrail');
+    if (workrailIndex <= 0) {
+        return path_1.default.basename(rootPath);
+    }
+    return segments[workrailIndex - 1];
+}

package/dist/mcp/handlers/v2-execution/index.js

@@ -16,6 +16,7 @@ const start_js_1 = require("./start.js");
 const continue_rehydrate_js_1 = require("./continue-rehydrate.js");
 const continue_advance_js_1 = require("./continue-advance.js");
 const render_envelope_js_1 = require("../../render-envelope.js");
+const remembered_roots_js_1 = require("../shared/remembered-roots.js");
 function buildNextCall(args) {
     if (args.isComplete && !args.pending)
         return null;
@@ -31,6 +32,9 @@ async function handleV2StartWorkflow(input, ctx) {
     const guard = (0, types_js_1.requireV2Context)(ctx);
     if (!guard.ok)
         return guard.error;
+    const rememberedRootFailure = await (0, remembered_roots_js_1.rememberExplicitWorkspaceRoot)(input.workspacePath, guard.ctx.v2.rememberedRootsStore);
+    if (rememberedRootFailure)
+        return rememberedRootFailure;
     return (0, start_js_1.executeStartWorkflow)(input, guard.ctx).match((result) => (0, types_js_1.success)((0, render_envelope_js_1.attachV2ExecutionRenderMetadata)({
         response: result.response,
         lifecycle: 'start',

package/dist/mcp/handlers/v2-execution/start.js

@@ -219,10 +219,11 @@ function executeStartWorkflow(input, ctx) {
     const workflowReader = shouldUseRequestReader
         ? {
             getWorkflowById: async (workflowId) => {
-                const requestReader = (0, request_workflow_reader_js_1.createWorkflowReaderForRequest)({
+                const requestReader = await (0, request_workflow_reader_js_1.createWorkflowReaderForRequest)({
                     featureFlags: ctx.featureFlags,
                     workspacePath: input.workspacePath,
                     resolvedRootUris: ctx.v2.resolvedRootUris,
+                    rememberedRootsStore: ctx.v2.rememberedRootsStore,
                 });
                 const requestResult = await requestReader.getWorkflowById(workflowId);
                 if (requestResult != null)