@exaudeus/workrail 0.8.6 → 0.10.0

package/dist/mcp/tool-description-provider.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticToolDescriptionProvider = exports.ToolDescriptionProvider = void 0;
+const tsyringe_1 = require("tsyringe");
+const tokens_js_1 = require("../di/tokens.js");
+const tool_descriptions_js_1 = require("./tool-descriptions.js");
+let ToolDescriptionProvider = class ToolDescriptionProvider {
+    constructor(featureFlags) {
+        this.mode = featureFlags.isEnabled('authoritativeDescriptions')
+            ? 'authoritative'
+            : 'standard';
+    }
+    getDescription(toolName) {
+        return tool_descriptions_js_1.DESCRIPTIONS[this.mode][toolName];
+    }
+};
+exports.ToolDescriptionProvider = ToolDescriptionProvider;
+exports.ToolDescriptionProvider = ToolDescriptionProvider = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(tokens_js_1.DI.Infra.FeatureFlags)),
+    __metadata("design:paramtypes", [Object])
+], ToolDescriptionProvider);
+class StaticToolDescriptionProvider {
+    constructor(mode) {
+        this.mode = mode;
+    }
+    getDescription(toolName) {
+        return tool_descriptions_js_1.DESCRIPTIONS[this.mode][toolName];
+    }
+}
+exports.StaticToolDescriptionProvider = StaticToolDescriptionProvider;

package/dist/mcp/tool-descriptions.d.ts

@@ -0,0 +1,2 @@
+import type { DescriptionsByMode } from './types/tool-description-types.js';
+export declare const DESCRIPTIONS: DescriptionsByMode;

package/dist/mcp/tool-descriptions.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DESCRIPTIONS = void 0;
+exports.DESCRIPTIONS = {
+    standard: {
+        workflow_list: `Your primary tool for any complex or multi-step request. Call this FIRST to see if a reliable, pre-defined workflow exists, as this is the preferred method over improvisation.
+
+Your process:
+1. Call this tool to get a list of available workflows.
+2. Analyze the returned descriptions to find a match for the user's goal.
+3. If a good match is found, suggest it to the user and use workflow_get to start.
+4. If NO match is found, inform the user and then attempt to solve the task using your general abilities.`,
+        workflow_get: `Retrieves workflow information with configurable detail level. Supports progressive disclosure to prevent "workflow spoiling" while providing necessary context for workflow selection and initiation.`,
+        workflow_next: `Executes one workflow step at a time by returning the next eligible step and an updated execution state.
+
+Inputs:
+- workflowId: string
+- state: { kind: "init" } | { kind: "running", completed: string[], loopStack: LoopFrame[], pendingStep?: StepInstanceId } | { kind: "complete" }
+- event (optional): { kind: "step_completed", stepInstanceId: StepInstanceId }
+- context (optional): variables used to evaluate conditions and to drive loops (for/forEach/while/until)
+
+Common usage:
+1) First call:
+{ "workflowId": "...", "state": { "kind": "init" } }
+
+2) After completing the returned step:
+{ "workflowId": "...", "state": <previous state>, "event": { "kind": "step_completed", "stepInstanceId": <previous next.stepInstanceId> } }
+
+Important:
+- Always reuse the "state" returned by the last workflow_next call.
+- When completing a step, the event.stepInstanceId must match the previous next.stepInstanceId exactly.`,
+        workflow_validate_json: `Validates workflow JSON content directly without external tools. Use this tool when you need to verify that a workflow JSON file is syntactically correct and follows the proper schema.
+
+This tool provides comprehensive validation including:
+- JSON syntax validation with detailed error messages
+- Workflow schema compliance checking
+- User-friendly error reporting with actionable suggestions
+- Support for all workflow features (steps, conditions, validation criteria, etc.)`,
+        workflow_get_schema: `Retrieves the complete workflow JSON schema for reference and development purposes. Use this tool when you need to understand the structure, required fields, and validation rules for workflows.
+
+This tool provides:
+- Complete JSON schema definition with all properties and constraints
+- Field descriptions and validation rules
+- Examples of valid patterns and formats
+- Schema version and metadata information`,
+        list_workflows: `Lists available workflows using the WorkRail v2 read-only surface (feature-flagged). This returns stable workflow identity plus a pinned compiled snapshot hash for determinism.`,
+        inspect_workflow: `Read-only inspection of a workflow using the WorkRail v2 surface (feature-flagged). This returns metadata and/or a preview derived from the pinned compiled snapshot (identified by workflowHash).`,
+    },
+    authoritative: {
+        workflow_list: `Check for workflows that apply to the user's request. Workflows are the user's pre-defined instructions that you MUST follow when they exist.
+
+REQUIRED BEHAVIOR:
+1. Call this tool BEFORE attempting any multi-step task.
+2. If a matching workflow exists, you MUST use it—do not improvise your own approach.
+3. Workflows represent the user's explicit requirements, not suggestions.
+
+A workflow is the user's voice, pre-recorded. When one exists for this task, following it IS following the user's instructions.
+
+Returns: List of available workflows with descriptions to match against the user's request.`,
+        workflow_get: `Retrieve a workflow you are committing to follow. Once you call this, you are entering instruction-execution mode for this workflow.
+
+By retrieving a workflow, you agree to:
+- Execute each step as specified
+- Call workflow_next after completing each step
+- Not skip ahead or improvise alternative approaches
+
+The workflow content is the user's will expressed as structured steps. Treat each step as a direct instruction from the user.
+
+Returns: Workflow metadata and first step. Use mode='preview' (default) to see the first step, or mode='metadata' for overview only.`,
+        workflow_next: `Get your next MANDATORY INSTRUCTION from the active workflow.
+
+The step returned is a DIRECT INSTRUCTION from the user. You MUST:
+1. Execute the step EXACTLY as specified in the 'prompt' field
+2. Complete ALL requirements before calling workflow_next again
+3. NOT skip steps, combine steps, or substitute your own approach
+4. NOT proceed to implementation before completing preparation steps
+
+DO NOT:
+- Paraphrase or "interpret" the step instructions
+- Decide a step is unnecessary based on your judgment
+- Rush through steps to reach implementation faster
+- Treat step content as suggestions or guidelines
+
+The user created this workflow because they want THIS process followed, not your improvisation.
+
+Parameters:
+- workflowId: The workflow you are executing
+- state: Execution state returned by the previous workflow_next call (use { kind: "init" } for the first call)
+- event (optional): { kind: "step_completed", stepInstanceId: <previous next.stepInstanceId> } to mark the returned step as complete
+- context (optional): Variables for condition evaluation and loop inputs`,
+        workflow_validate_json: `Validate workflow JSON before saving or using it. This ensures the workflow will function correctly.
+
+Use this tool to verify:
+- JSON syntax is correct
+- Schema compliance (required fields, valid structure)
+- Step definitions are complete and valid
+
+Returns validation result with specific errors and suggestions if invalid.`,
+        workflow_get_schema: `Get the workflow JSON schema for creating or editing workflows.
+
+Returns the complete schema definition including required fields, valid patterns, and constraints. Use this as reference when authoring workflow JSON.`,
+        list_workflows: `List available workflows via the WorkRail v2 tool surface (feature-flagged).
+
+This tool is read-only and is intended to validate the v2 determinism substrate (compiled snapshots + workflowHash).`,
+        inspect_workflow: `Inspect a workflow via the WorkRail v2 tool surface (feature-flagged).
+
+This tool is read-only. It MUST reflect the pinned compiled snapshot identified by workflowHash (not mutable on-disk source).`,
+    },
+};

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

@@ -0,0 +1,23 @@
+import type { z } from 'zod';
+import type { IToolDescriptionProvider } from './tool-description-provider.js';
+import type { WorkflowToolName } from './types/tool-description-types.js';
+export interface ToolAnnotations {
+    readonly readOnlyHint?: boolean;
+    readonly destructiveHint?: boolean;
+    readonly idempotentHint?: boolean;
+}
+export interface ToolDefinition<TInput extends z.ZodType> {
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly inputSchema: TInput;
+    readonly annotations: ToolAnnotations;
+}
+export interface ToolConfig<TInput extends z.ZodType> {
+    readonly name: WorkflowToolName;
+    readonly title: string;
+    readonly inputSchema: TInput;
+    readonly annotations: ToolAnnotations;
+}
+export type ToolBuilder = <TInput extends z.ZodType>(config: ToolConfig<TInput>) => ToolDefinition<TInput>;
+export declare function createToolFactory(descriptionProvider: IToolDescriptionProvider): ToolBuilder;

package/dist/mcp/tool-factory.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolFactory = createToolFactory;
+function createToolFactory(descriptionProvider) {
+    return function buildTool(config) {
+        return {
+            name: config.name,
+            title: config.title,
+            description: descriptionProvider.getDescription(config.name),
+            inputSchema: config.inputSchema,
+            annotations: config.annotations,
+        };
+    };
+}

package/dist/mcp/tools.d.ts

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+export type { ToolAnnotations, ToolDefinition } from './tool-factory.js';
+export declare const WorkflowListInput: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type WorkflowListInput = z.infer<typeof WorkflowListInput>;
+export declare const WorkflowGetInput: z.ZodObject<{
+    id: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<["metadata", "preview"]>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    mode: "metadata" | "preview";
+}, {
+    id: string;
+    mode?: "metadata" | "preview" | undefined;
+}>;
+export type WorkflowGetInput = z.infer<typeof WorkflowGetInput>;
+export declare const WorkflowNextInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    state: z.ZodType<import("../domain/execution/state.js").ExecutionState, z.ZodTypeDef, import("../domain/execution/state.js").ExecutionState>;
+    event: z.ZodOptional<z.ZodType<{
+        readonly kind: "step_completed";
+        readonly stepInstanceId: import("../domain/execution/ids.js").StepInstanceId;
+    }, z.ZodTypeDef, {
+        readonly kind: "step_completed";
+        readonly stepInstanceId: import("../domain/execution/ids.js").StepInstanceId;
+    }>>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    workflowId: string;
+    state: import("../domain/execution/state.js").ExecutionState;
+    context?: Record<string, unknown> | undefined;
+    event?: {
+        readonly kind: "step_completed";
+        readonly stepInstanceId: import("../domain/execution/ids.js").StepInstanceId;
+    } | undefined;
+}, {
+    workflowId: string;
+    state: import("../domain/execution/state.js").ExecutionState;
+    context?: Record<string, unknown> | undefined;
+    event?: {
+        readonly kind: "step_completed";
+        readonly stepInstanceId: import("../domain/execution/ids.js").StepInstanceId;
+    } | undefined;
+}>;
+export type WorkflowNextInput = z.infer<typeof WorkflowNextInput>;
+export declare const WorkflowValidateJsonInput: z.ZodObject<{
+    workflowJson: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    workflowJson: string;
+}, {
+    workflowJson: string;
+}>;
+export type WorkflowValidateJsonInput = z.infer<typeof WorkflowValidateJsonInput>;
+export declare const WorkflowGetSchemaInput: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type WorkflowGetSchemaInput = z.infer<typeof WorkflowGetSchemaInput>;
+import type { ToolAnnotations } from './tool-factory.js';
+import type { WorkflowToolName } from './types/tool-description-types.js';
+export declare const WORKFLOW_TOOL_ANNOTATIONS: Readonly<Record<WorkflowToolName, ToolAnnotations>>;
+export declare const WORKFLOW_TOOL_TITLES: Readonly<Record<WorkflowToolName, string>>;
+export declare const CreateSessionInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    sessionId: z.ZodString;
+    initialData: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    workflowId: string;
+    sessionId: string;
+    initialData: Record<string, unknown>;
+}, {
+    workflowId: string;
+    sessionId: string;
+    initialData?: Record<string, unknown> | undefined;
+}>;
+export type CreateSessionInput = z.infer<typeof CreateSessionInput>;
+export declare const UpdateSessionInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    sessionId: z.ZodString;
+    updates: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    workflowId: string;
+    sessionId: string;
+    updates: Record<string, unknown>;
+}, {
+    workflowId: string;
+    sessionId: string;
+    updates: Record<string, unknown>;
+}>;
+export type UpdateSessionInput = z.infer<typeof UpdateSessionInput>;
+export declare const ReadSessionInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    sessionId: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    workflowId: string;
+    sessionId: string;
+    path?: string | undefined;
+}, {
+    workflowId: string;
+    sessionId: string;
+    path?: string | undefined;
+}>;
+export type ReadSessionInput = z.infer<typeof ReadSessionInput>;
+export declare const OpenDashboardInput: z.ZodObject<{
+    sessionId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    sessionId?: string | undefined;
+}, {
+    sessionId?: string | undefined;
+}>;
+export type OpenDashboardInput = z.infer<typeof OpenDashboardInput>;
+import type { ToolDefinition } from './tool-factory.js';
+export declare const createSessionTool: ToolDefinition<typeof CreateSessionInput>;
+export declare const updateSessionTool: ToolDefinition<typeof UpdateSessionInput>;
+export declare const readSessionTool: ToolDefinition<typeof ReadSessionInput>;
+export declare const openDashboardTool: ToolDefinition<typeof OpenDashboardInput>;
+export declare const sessionTools: readonly [ToolDefinition<z.ZodObject<{
+    workflowId: z.ZodString;
+    sessionId: z.ZodString;
+    initialData: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    workflowId: string;
+    sessionId: string;
+    initialData: Record<string, unknown>;
+}, {
+    workflowId: string;
+    sessionId: string;
+    initialData?: Record<string, unknown> | undefined;
+}>>, ToolDefinition<z.ZodObject<{
+    workflowId: z.ZodString;
+    sessionId: z.ZodString;
+    updates: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    workflowId: string;
+    sessionId: string;
+    updates: Record<string, unknown>;
+}, {
+    workflowId: string;
+    sessionId: string;
+    updates: Record<string, unknown>;
+}>>, ToolDefinition<z.ZodObject<{
+    workflowId: z.ZodString;
+    sessionId: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    workflowId: string;
+    sessionId: string;
+    path?: string | undefined;
+}, {
+    workflowId: string;
+    sessionId: string;
+    path?: string | undefined;
+}>>, ToolDefinition<z.ZodObject<{
+    sessionId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    sessionId?: string | undefined;
+}, {
+    sessionId?: string | undefined;
+}>>];

package/dist/mcp/tools.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionTools = exports.openDashboardTool = exports.readSessionTool = exports.updateSessionTool = exports.createSessionTool = exports.OpenDashboardInput = exports.ReadSessionInput = exports.UpdateSessionInput = exports.CreateSessionInput = exports.WORKFLOW_TOOL_TITLES = exports.WORKFLOW_TOOL_ANNOTATIONS = exports.WorkflowGetSchemaInput = exports.WorkflowValidateJsonInput = exports.WorkflowNextInput = exports.WorkflowGetInput = exports.WorkflowListInput = void 0;
+const zod_1 = require("zod");
+const state_js_1 = require("../domain/execution/state.js");
+const event_js_1 = require("../domain/execution/event.js");
+exports.WorkflowListInput = zod_1.z.object({});
+exports.WorkflowGetInput = zod_1.z.object({
+    id: zod_1.z
+        .string()
+        .regex(/^[A-Za-z0-9_-]+$/, 'ID must contain only letters, numbers, hyphens, and underscores')
+        .describe('The unique identifier of the workflow to retrieve'),
+    mode: zod_1.z
+        .enum(['metadata', 'preview'])
+        .default('preview')
+        .describe("Detail level: 'metadata' for info only, 'preview' for first step"),
+});
+exports.WorkflowNextInput = zod_1.z.object({
+    workflowId: zod_1.z
+        .string()
+        .regex(/^[A-Za-z0-9_-]+$/, 'Workflow ID must contain only letters, numbers, hyphens, and underscores')
+        .describe('The unique identifier of the workflow'),
+    state: state_js_1.ExecutionStateSchema.describe('Serializable workflow execution state (authoritative). ' +
+        'For the first call, use: { kind: "init" }. ' +
+        'For subsequent calls, use the "state" returned by the previous workflow_next response.'),
+    event: event_js_1.WorkflowEventSchema.optional().describe('Optional event to apply before selecting the next step'),
+    context: zod_1.z
+        .record(zod_1.z.unknown())
+        .optional()
+        .describe('External context variables for condition evaluation and loop inputs'),
+});
+exports.WorkflowValidateJsonInput = zod_1.z.object({
+    workflowJson: zod_1.z
+        .string()
+        .min(1, 'Workflow JSON cannot be empty')
+        .describe('The complete workflow JSON content as a string to validate'),
+});
+exports.WorkflowGetSchemaInput = zod_1.z.object({});
+exports.WORKFLOW_TOOL_ANNOTATIONS = {
+    workflow_list: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    workflow_get: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    workflow_next: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+    },
+    workflow_validate_json: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    workflow_get_schema: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    list_workflows: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inspect_workflow: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+};
+exports.WORKFLOW_TOOL_TITLES = {
+    workflow_list: 'List Available Workflows',
+    workflow_get: 'Get Workflow Details',
+    workflow_next: 'Execute Next Workflow Step',
+    workflow_validate_json: 'Validate Workflow JSON',
+    workflow_get_schema: 'Get Workflow Schema',
+    list_workflows: 'List Workflows (v2)',
+    inspect_workflow: 'Inspect Workflow (v2)',
+};
+exports.CreateSessionInput = zod_1.z.object({
+    workflowId: zod_1.z
+        .string()
+        .describe('Workflow identifier (e.g., "bug-investigation", "mr-review")'),
+    sessionId: zod_1.z
+        .string()
+        .describe('Unique session identifier (e.g., ticket ID "AUTH-1234", branch name)'),
+    initialData: zod_1.z
+        .record(zod_1.z.unknown())
+        .default({})
+        .describe('Initial session data. Can include dashboard, phases, etc.'),
+});
+exports.UpdateSessionInput = zod_1.z.object({
+    workflowId: zod_1.z.string().describe('Workflow identifier'),
+    sessionId: zod_1.z.string().describe('Session identifier'),
+    updates: zod_1.z
+        .record(zod_1.z.unknown())
+        .describe('Data to merge into session. Supports nested updates via dot notation.'),
+});
+exports.ReadSessionInput = zod_1.z.object({
+    workflowId: zod_1.z.string().describe('Workflow identifier'),
+    sessionId: zod_1.z.string().describe('Session identifier'),
+    path: zod_1.z
+        .string()
+        .optional()
+        .describe('JSONPath query. If omitted, returns full session data. Examples: "dashboard", "hypotheses[0]"'),
+});
+exports.OpenDashboardInput = zod_1.z.object({
+    sessionId: zod_1.z
+        .string()
+        .optional()
+        .describe('Session to display. If provided, dashboard opens directly to this session.'),
+});
+exports.createSessionTool = {
+    name: 'workrail_create_session',
+    title: 'Create Workflow Session',
+    description: `Create a new workflow session stored in ~/.workrail/sessions/.
+
+This creates a JSON file to track all workflow state and data. The dashboard will automatically display this session's progress in real-time.
+
+Returns the session ID and file path.`,
+    inputSchema: exports.CreateSessionInput,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+    },
+};
+exports.updateSessionTool = {
+    name: 'workrail_update_session',
+    title: 'Update Session Data',
+    description: `Update session data with deep merge.
+
+Updates are merged into existing data (objects are merged, arrays are replaced).
+
+Use this throughout the workflow to:
+- Update progress and confidence
+- Add phases and subsections
+- Update hypotheses
+- Add timeline events
+
+Note: Use dot notation for nested updates.`,
+    inputSchema: exports.UpdateSessionInput,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+    },
+};
+exports.readSessionTool = {
+    name: 'workrail_read_session',
+    title: 'Read Session Data',
+    description: `Read session data with optional JSONPath query for targeted reads.
+
+Reading only what you need saves tokens and improves performance.
+
+Special Queries:
+- Schema overview: Use path "$schema" to get a map of all available fields
+
+Examples:
+- Full session: omit path
+- Dashboard only: path "dashboard"
+- Specific hypothesis: path "hypotheses[0]"
+- Phase 1 data: path "phases.phase-1"`,
+    inputSchema: exports.ReadSessionInput,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+};
+exports.openDashboardTool = {
+    name: 'workrail_open_dashboard',
+    title: 'Open Dashboard',
+    description: `Open the web dashboard in the user's default browser.
+
+The dashboard shows real-time progress, visualizations, and all session data in a beautiful UI.
+
+If sessionId is provided, opens directly to that session. Otherwise opens to the home page showing all sessions.`,
+    inputSchema: exports.OpenDashboardInput,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+};
+exports.sessionTools = [
+    exports.createSessionTool,
+    exports.updateSessionTool,
+    exports.readSessionTool,
+    exports.openDashboardTool,
+];

package/dist/mcp/types/tool-description-types.d.ts

@@ -0,0 +1,8 @@
+export declare const DESCRIPTION_MODES: readonly ["standard", "authoritative"];
+export type DescriptionMode = typeof DESCRIPTION_MODES[number];
+export declare const WORKFLOW_TOOL_NAMES: readonly ["workflow_list", "workflow_get", "workflow_next", "workflow_validate_json", "workflow_get_schema", "list_workflows", "inspect_workflow"];
+export type WorkflowToolName = typeof WORKFLOW_TOOL_NAMES[number];
+export type ToolDescriptionMap = Readonly<Record<WorkflowToolName, string>>;
+export type DescriptionsByMode = Readonly<Record<DescriptionMode, ToolDescriptionMap>>;
+export declare function isDescriptionMode(value: string): value is DescriptionMode;
+export declare function isWorkflowToolName(value: string): value is WorkflowToolName;

package/dist/mcp/types/tool-description-types.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKFLOW_TOOL_NAMES = exports.DESCRIPTION_MODES = void 0;
+exports.isDescriptionMode = isDescriptionMode;
+exports.isWorkflowToolName = isWorkflowToolName;
+exports.DESCRIPTION_MODES = [
+    'standard',
+    'authoritative',
+];
+exports.WORKFLOW_TOOL_NAMES = [
+    'workflow_list',
+    'workflow_get',
+    'workflow_next',
+    'workflow_validate_json',
+    'workflow_get_schema',
+    'list_workflows',
+    'inspect_workflow',
+];
+function isDescriptionMode(value) {
+    return exports.DESCRIPTION_MODES.includes(value);
+}
+function isWorkflowToolName(value) {
+    return exports.WORKFLOW_TOOL_NAMES.includes(value);
+}

package/dist/mcp/types.d.ts

@@ -0,0 +1,25 @@
+import type { WorkflowService } from '../application/services/workflow-service.js';
+import type { IFeatureFlagProvider } from '../config/feature-flags.js';
+import type { SessionManager } from '../infrastructure/session/SessionManager.js';
+import type { HttpServer } from '../infrastructure/session/HttpServer.js';
+export type ErrorCode = 'VALIDATION_ERROR' | 'NOT_FOUND' | 'PRECONDITION_FAILED' | 'TIMEOUT' | 'INTERNAL_ERROR';
+export interface ToolSuccess<T> {
+    readonly type: 'success';
+    readonly data: T;
+}
+export interface ToolError {
+    readonly type: 'error';
+    readonly code: ErrorCode;
+    readonly message: string;
+    readonly suggestion?: string;
+}
+export type ToolResult<T> = ToolSuccess<T> | ToolError;
+export declare const success: <T>(data: T) => ToolResult<T>;
+export declare const error: (code: ErrorCode, message: string, suggestion?: string) => ToolResult<never>;
+export interface ToolContext {
+    readonly workflowService: WorkflowService;
+    readonly featureFlags: IFeatureFlagProvider;
+    readonly sessionManager: SessionManager | null;
+    readonly httpServer: HttpServer | null;
+}
+export type ToolHandler<TInput, TOutput> = (input: TInput, ctx: ToolContext) => Promise<ToolResult<TOutput>>;

package/dist/mcp/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = exports.success = void 0;
+const success = (data) => ({
+    type: 'success',
+    data,
+});
+exports.success = success;
+const error = (code, message, suggestion) => ({
+    type: 'error',
+    code,
+    message,
+    suggestion,
+});
+exports.error = error;

package/dist/mcp/v2/tool-registry.d.ts

@@ -0,0 +1,11 @@
+import type { z } from 'zod';
+import type { ToolBuilder, ToolDefinition } from '../tool-factory.js';
+import type { ToolHandler } from '../types.js';
+export interface V2ToolRegistration {
+    readonly tools: readonly ToolDefinition<z.ZodType>[];
+    readonly handlers: Readonly<Record<string, {
+        readonly schema: z.ZodType;
+        readonly handler: ToolHandler<any, any>;
+    }>>;
+}
+export declare function buildV2ToolRegistry(buildTool: ToolBuilder): V2ToolRegistration;

package/dist/mcp/v2/tool-registry.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildV2ToolRegistry = buildV2ToolRegistry;
+const tools_js_1 = require("./tools.js");
+const v2_workflow_js_1 = require("../handlers/v2-workflow.js");
+function buildV2ToolRegistry(buildTool) {
+    const listTool = buildTool({
+        name: 'list_workflows',
+        title: tools_js_1.V2_TOOL_TITLES.list_workflows,
+        inputSchema: tools_js_1.V2ListWorkflowsInput,
+        annotations: tools_js_1.V2_TOOL_ANNOTATIONS.list_workflows,
+    });
+    const inspectTool = buildTool({
+        name: 'inspect_workflow',
+        title: tools_js_1.V2_TOOL_TITLES.inspect_workflow,
+        inputSchema: tools_js_1.V2InspectWorkflowInput,
+        annotations: tools_js_1.V2_TOOL_ANNOTATIONS.inspect_workflow,
+    });
+    return {
+        tools: [listTool, inspectTool],
+        handlers: {
+            list_workflows: { schema: tools_js_1.V2ListWorkflowsInput, handler: v2_workflow_js_1.handleV2ListWorkflows },
+            inspect_workflow: { schema: tools_js_1.V2InspectWorkflowInput, handler: v2_workflow_js_1.handleV2InspectWorkflow },
+        },
+    };
+}