@exaudeus/workrail 3.3.0 → 3.5.0

package/dist/mcp/transports/shutdown-hooks.d.ts

@@ -0,0 +1,5 @@
+export interface ShutdownHookOptions {
+    readonly onBeforeTerminate: () => Promise<void>;
+}
+export declare function wireShutdownHooks(opts: ShutdownHookOptions): void;
+export declare function wireStdinShutdown(): void;

package/dist/mcp/transports/shutdown-hooks.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wireShutdownHooks = wireShutdownHooks;
+exports.wireStdinShutdown = wireStdinShutdown;
+const container_js_1 = require("../../di/container.js");
+const tokens_js_1 = require("../../di/tokens.js");
+function wireShutdownHooks(opts) {
+    const shutdownEvents = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ShutdownEvents);
+    const processSignals = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessSignals);
+    const terminator = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessTerminator);
+    processSignals.on('SIGINT', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGINT' }));
+    processSignals.on('SIGTERM', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGTERM' }));
+    processSignals.on('SIGHUP', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' }));
+    let shutdownStarted = false;
+    shutdownEvents.onShutdown((event) => {
+        if (shutdownStarted)
+            return;
+        shutdownStarted = true;
+        void (async () => {
+            try {
+                console.error(`[Shutdown] Requested by ${event.signal}. Stopping services...`);
+                await opts.onBeforeTerminate();
+                terminator.terminate({ kind: 'success' });
+            }
+            catch (err) {
+                console.error('[Shutdown] Error while stopping services:', err);
+                terminator.terminate({ kind: 'failure' });
+            }
+        })();
+    });
+}
+function wireStdinShutdown() {
+    const shutdownEvents = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ShutdownEvents);
+    process.stdin.on('end', () => {
+        console.error('[MCP] stdin closed, initiating shutdown');
+        shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' });
+    });
+}

package/dist/mcp/transports/stdio-entry.js

@@ -35,8 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startStdioServer = startStdioServer;
 const server_js_1 = require("../server.js");
-const container_js_1 = require("../../di/container.js");
-const tokens_js_1 = require("../../di/tokens.js");
+const shutdown_hooks_js_1 = require("./shutdown-hooks.js");
 async function startStdioServer() {
     const { server, ctx, rootsManager } = await (0, server_js_1.composeServer)();
     const { StdioServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/stdio.js')));
@@ -62,31 +61,10 @@ async function startStdioServer() {
         console.error('[Roots] Client does not support roots/list; workspace context will use server CWD fallback');
     }
     console.error('[Transport] WorkRail MCP Server running on stdio');
-    const shutdownEvents = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ShutdownEvents);
-    const processSignals = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessSignals);
-    const terminator = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessTerminator);
-    processSignals.on('SIGINT', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGINT' }));
-    processSignals.on('SIGTERM', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGTERM' }));
-    processSignals.on('SIGHUP', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' }));
-    process.stdin.on('end', () => {
-        console.error('[MCP] stdin closed, initiating shutdown');
-        shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' });
-    });
-    let shutdownStarted = false;
-    shutdownEvents.onShutdown((event) => {
-        if (shutdownStarted)
-            return;
-        shutdownStarted = true;
-        void (async () => {
-            try {
-                console.error(`[Shutdown] Requested by ${event.signal}. Stopping services...`);
-                await ctx.httpServer?.stop();
-                terminator.terminate({ kind: 'success' });
-            }
-            catch (err) {
-                console.error('[Shutdown] Error while stopping services:', err);
-                terminator.terminate({ kind: 'failure' });
-            }
-        })();
+    (0, shutdown_hooks_js_1.wireShutdownHooks)({
+        onBeforeTerminate: async () => {
+            await ctx.httpServer?.stop();
+        },
     });
+    (0, shutdown_hooks_js_1.wireStdinShutdown)();
 }

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

@@ -7,6 +7,7 @@ const v2_execution_js_1 = require("../handlers/v2-execution.js");
 const v2_workflow_js_1 = require("../handlers/v2-workflow.js");
 const v2_checkpoint_js_1 = require("../handlers/v2-checkpoint.js");
 const v2_resume_js_1 = require("../handlers/v2-resume.js");
+const workflow_protocol_contracts_js_1 = require("../workflow-protocol-contracts.js");
 function buildV2ToolRegistry(buildTool) {
     const tools = [
         buildTool({
@@ -50,7 +51,7 @@ function buildV2ToolRegistry(buildTool) {
         list_workflows: (0, handler_factory_js_1.createHandler)(tools_js_1.V2ListWorkflowsInput, v2_workflow_js_1.handleV2ListWorkflows),
         inspect_workflow: (0, handler_factory_js_1.createHandler)(tools_js_1.V2InspectWorkflowInput, v2_workflow_js_1.handleV2InspectWorkflow),
         start_workflow: (0, handler_factory_js_1.createHandler)(tools_js_1.V2StartWorkflowInput, v2_execution_js_1.handleV2StartWorkflow),
-        continue_workflow: (0, handler_factory_js_1.createHandler)(tools_js_1.V2ContinueWorkflowInput, v2_execution_js_1.handleV2ContinueWorkflow, tools_js_1.V2ContinueWorkflowInputShape),
+        continue_workflow: (0, handler_factory_js_1.createHandler)(tools_js_1.V2ContinueWorkflowInput, v2_execution_js_1.handleV2ContinueWorkflow, tools_js_1.V2ContinueWorkflowInputShape, workflow_protocol_contracts_js_1.CONTINUE_WORKFLOW_PROTOCOL.aliasMap),
         checkpoint_workflow: (0, handler_factory_js_1.createHandler)(tools_js_1.V2CheckpointWorkflowInput, v2_checkpoint_js_1.handleV2CheckpointWorkflow),
         resume_session: (0, handler_factory_js_1.createHandler)(tools_js_1.V2ResumeSessionInput, v2_resume_js_1.handleV2ResumeSession),
     };

package/dist/mcp/v2/tools.d.ts

@@ -18,8 +18,8 @@ export declare const V2InspectWorkflowInput: z.ZodObject<{
     workspacePath?: string | undefined;
 }, {
     workflowId: string;
-    mode?: "metadata" | "preview" | undefined;
     workspacePath?: string | undefined;
+    mode?: "metadata" | "preview" | undefined;
 }>;
 export type V2InspectWorkflowInput = z.infer<typeof V2InspectWorkflowInput>;
 export declare const V2StartWorkflowInput: z.ZodObject<{
@@ -34,6 +34,7 @@ export declare const V2StartWorkflowInput: z.ZodObject<{
 }>;
 export type V2StartWorkflowInput = z.infer<typeof V2StartWorkflowInput>;
 export declare const V2ContinueWorkflowInputShape: z.ZodObject<{
+    workspacePath: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     continueToken: z.ZodString;
     intent: z.ZodOptional<z.ZodEnum<["advance", "rehydrate"]>>;
     context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -50,21 +51,24 @@ export declare const V2ContinueWorkflowInputShape: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     continueToken: string;
     context?: Record<string, unknown> | undefined;
+    workspacePath?: string | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
 }, {
     continueToken: string;
     context?: Record<string, unknown> | undefined;
+    workspacePath?: string | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
 }>;
 export declare const V2ContinueWorkflowInput: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    workspacePath: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     continueToken: z.ZodString;
     intent: z.ZodOptional<z.ZodEnum<["advance", "rehydrate"]>>;
     context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -78,54 +82,67 @@ export declare const V2ContinueWorkflowInput: z.ZodEffects<z.ZodEffects<z.ZodObj
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     }>>;
+} & {
+    contextVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strict", z.ZodTypeAny, {
     continueToken: string;
     context?: Record<string, unknown> | undefined;
+    workspacePath?: string | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
+    contextVariables?: Record<string, unknown> | undefined;
 }, {
     continueToken: string;
     context?: Record<string, unknown> | undefined;
+    workspacePath?: string | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
+    contextVariables?: Record<string, unknown> | undefined;
 }>, {
     continueToken: string;
     context?: Record<string, unknown> | undefined;
+    workspacePath?: string | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
+    contextVariables?: Record<string, unknown> | undefined;
 }, {
     continueToken: string;
     context?: Record<string, unknown> | undefined;
+    workspacePath?: string | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
+    contextVariables?: Record<string, unknown> | undefined;
 }>, {
+    workspacePath?: string | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
-    context?: Record<string, unknown> | undefined;
+    context?: {} | undefined;
     intent: "advance" | "rehydrate";
     continueToken: string;
 }, {
     continueToken: string;
     context?: Record<string, unknown> | undefined;
+    workspacePath?: string | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
+    contextVariables?: Record<string, unknown> | undefined;
 }>;
 export type V2ContinueWorkflowInput = z.infer<typeof V2ContinueWorkflowInput>;
 export declare const V2ResumeSessionInput: z.ZodObject<{
@@ -134,13 +151,13 @@ export declare const V2ResumeSessionInput: z.ZodObject<{
     gitHeadSha: z.ZodOptional<z.ZodString>;
     workspacePath: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
 }, "strict", z.ZodTypeAny, {
-    query?: string | undefined;
     workspacePath?: string | undefined;
+    query?: string | undefined;
     gitBranch?: string | undefined;
     gitHeadSha?: string | undefined;
 }, {
-    query?: string | undefined;
     workspacePath?: string | undefined;
+    query?: string | undefined;
     gitBranch?: string | undefined;
     gitHeadSha?: string | undefined;
 }>;

package/dist/mcp/v2/tools.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.V2_TOOL_ANNOTATIONS = exports.V2_TOOL_TITLES = exports.V2CheckpointWorkflowInput = exports.V2ResumeSessionInput = exports.V2ContinueWorkflowInput = exports.V2ContinueWorkflowInputShape = exports.V2StartWorkflowInput = exports.V2InspectWorkflowInput = exports.V2ListWorkflowsInput = void 0;
 const zod_1 = require("zod");
+const workflow_protocol_contracts_js_1 = require("../workflow-protocol-contracts.js");
 const workspacePathField = zod_1.z.string()
     .refine((p) => p.startsWith('/'), 'workspacePath must be an absolute path (starting with /)')
     .optional()
@@ -19,8 +20,11 @@ exports.V2StartWorkflowInput = zod_1.z.object({
     workspacePath: workspacePathField.describe('Absolute path to your current workspace directory (e.g. the "Workspace:" value from your system parameters). Used to resolve the correct project-scoped workflow variant and to anchor this session to your workspace for future resume_session discovery. Pass this on every start_workflow call. If omitted, WorkRail uses MCP roots when available, then falls back to the server process directory.'),
 });
 exports.V2ContinueWorkflowInputShape = zod_1.z.object({
-    continueToken: zod_1.z.string().min(1).describe('The single token for your next continue_workflow call. Carries session identity AND advance authority. ' +
-        'Round-trip exactly as received from start_workflow or previous continue_workflow — never decode, inspect, or modify it.'),
+    workspacePath: workspacePathField,
+    continueToken: zod_1.z.string().min(1).describe('The token for your next continue_workflow call. Two valid token kinds: ' +
+        '(1) A continueToken (ct_...) from start_workflow or a previous continue_workflow — carries session identity AND advance authority. ' +
+        '(2) A resumeToken (st_...) from resume_session or checkpoint_workflow — carries session identity only; valid for intent: "rehydrate", not "advance". ' +
+        'Round-trip exactly as received — never decode, inspect, or modify it.'),
     intent: zod_1.z.enum(['advance', 'rehydrate']).optional().describe('What you want to do. Auto-inferred if omitted: ' +
         'output present → "advance", output absent → "rehydrate". ' +
         '"advance": I completed the current step. ' +
@@ -40,8 +44,23 @@ exports.V2ContinueWorkflowInputShape = zod_1.z.object({
         .optional()
         .describe('Durable output to attach to the current node. Only valid when intent is "advance".'),
 }).strict();
+const continueWorkflowContextAliasField = zod_1.z.record(zod_1.z.unknown()).optional().describe('Compatibility alias for context. Canonical field name: "context".');
 exports.V2ContinueWorkflowInput = exports.V2ContinueWorkflowInputShape
+    .extend({
+    contextVariables: continueWorkflowContextAliasField,
+})
     .superRefine((data, ctx) => {
+    const aliasMap = workflow_protocol_contracts_js_1.CONTINUE_WORKFLOW_PROTOCOL.aliasMap;
+    const conflicts = aliasMap
+        ? (0, workflow_protocol_contracts_js_1.findAliasFieldConflicts)(data, aliasMap)
+        : [];
+    for (const { alias, canonical } of conflicts) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: [alias],
+            message: `Provide either "${canonical}" or "${alias}", not both. Canonical field: "${canonical}".`,
+        });
+    }
     if (data.intent === 'rehydrate' && data.output) {
         ctx.addIssue({
             code: zod_1.z.ZodIssueCode.custom,
@@ -52,16 +71,21 @@ exports.V2ContinueWorkflowInput = exports.V2ContinueWorkflowInputShape
     }
 })
     .transform((data) => {
+    const normalized = workflow_protocol_contracts_js_1.CONTINUE_WORKFLOW_PROTOCOL.aliasMap
+        ? (0, workflow_protocol_contracts_js_1.normalizeAliasedFields)(data, workflow_protocol_contracts_js_1.CONTINUE_WORKFLOW_PROTOCOL.aliasMap)
+        : data;
     const intent = data.intent ?? (data.output ? 'advance' : 'rehydrate');
     return {
         intent,
         continueToken: data.continueToken,
-        ...(data.context ? { context: data.context } : {}),
+        ...(normalized.context ? { context: normalized.context } : {}),
         ...(data.output ? { output: data.output } : {}),
+        ...(data.workspacePath !== undefined ? { workspacePath: data.workspacePath } : {}),
     };
 });
 exports.V2ResumeSessionInput = zod_1.z.object({
-    query: zod_1.z.string().max(256).optional().describe('Free text search to find a relevant session. Matches against recap notes and workflow IDs.'),
+    query: zod_1.z.string().min(1).max(256).optional().describe('Free text search to find a relevant session. Matches against recap notes and workflow IDs. ' +
+        'Without query, only git-context matching runs — the semantic (notes) tier is skipped.'),
     gitBranch: zod_1.z.string().max(256).optional().describe('Git branch name to match against session observations. Overrides auto-detected branch.'),
     gitHeadSha: zod_1.z.string().regex(/^[0-9a-f]{40}$/).optional().describe('Git HEAD SHA to match against session observations. Overrides auto-detected HEAD.'),
     workspacePath: zod_1.z.string()

package/dist/mcp/v2-response-formatter.js

@@ -59,13 +59,30 @@ function formatTokenBlock(data) {
     lines.push('```');
     return lines.join('\n');
 }
-function formatComplete(_data) {
+function formatBindingDriftWarnings(data) {
+    if (!data.warnings || data.warnings.length === 0)
+        return '';
+    const lines = [
+        '',
+        '> **⚠ Binding Drift Detected**',
+        '> Your `.workrail/bindings.json` has changed since this session was started.',
+        '> The session continues with the original compiled bindings. Start a new session to pick up the changes.',
+        '>',
+    ];
+    for (const w of data.warnings) {
+        lines.push(`> - \`${w.slotId}\`: was \`${w.pinnedValue}\`, now \`${w.currentValue}\``);
+    }
+    return lines.join('\n');
+}
+function formatComplete(data) {
+    const driftBlock = formatBindingDriftWarnings(data);
     return [
         PERSONA_SYSTEM,
         '',
         '# Workflow Complete',
         '',
         'The workflow has finished. No further steps to execute.',
+        ...(driftBlock ? [driftBlock] : []),
     ].join('\n');
 }
 function formatBlocked(data) {
@@ -155,6 +172,11 @@ function formatRehydrate(data) {
         lines.push('No pending step. The workflow may be complete or waiting for external input.');
         lines.push('');
     }
+    const driftBlock = formatBindingDriftWarnings(data);
+    if (driftBlock) {
+        lines.push(driftBlock);
+        lines.push('');
+    }
     lines.push('Continue working on this step. When done, call `continue_workflow` to advance.');
     return lines.join('\n');
 }
@@ -178,6 +200,11 @@ function formatSuccess(data) {
     lines.push('Include `output.notesMarkdown` documenting your work — what you did, key decisions, what you produced, and anything notable.');
     lines.push('');
     lines.push(formatPreferences(data.preferences));
+    const driftBlock = formatBindingDriftWarnings(data);
+    if (driftBlock) {
+        lines.push('');
+        lines.push(driftBlock);
+    }
     return lines.join('\n');
 }
 function formatV2ExecutionResponse(data) {

package/dist/mcp/validation/suggestion-generator.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import type { SuggestionConfig } from './suggestion-config.js';
 import type { SuggestionResult } from './suggestion-types.js';
 export type { ZodIssue } from 'zod';
-export declare function generateSuggestions(args: unknown, schema: z.ZodType, config: SuggestionConfig): SuggestionResult;
+export declare function generateSuggestions(args: unknown, schema: z.ZodType, config: SuggestionConfig, aliasMap?: Readonly<Record<string, string>>): SuggestionResult;
 export declare function formatSuggestionDetails(result: SuggestionResult): Record<string, unknown>;
 export declare function hasSuggestions(result: SuggestionResult): boolean;
 export declare function patchTemplateForFailedOptionals(correctTemplate: Readonly<Record<string, unknown>> | null, args: unknown, zodErrors: readonly z.ZodIssue[], schema: z.ZodType, maxDepth: number): Readonly<Record<string, unknown>> | null;

package/dist/mcp/validation/suggestion-generator.js

@@ -8,9 +8,19 @@ const zod_1 = require("zod");
 const suggestion_types_js_1 = require("./suggestion-types.js");
 const string_similarity_js_1 = require("./string-similarity.js");
 const schema_introspection_js_1 = require("./schema-introspection.js");
-function generateUnknownKeySuggestions(unknownKeys, expectedKeys, config) {
+function generateUnknownKeySuggestions(unknownKeys, expectedKeys, config, aliasMap) {
     const suggestions = [];
     for (const unknownKey of unknownKeys) {
+        const aliasTarget = aliasMap?.[unknownKey];
+        if (aliasTarget) {
+            suggestions.push({
+                kind: 'unknown_key',
+                provided: unknownKey,
+                didYouMean: aliasTarget,
+                similarity: (0, suggestion_types_js_1.similarity)(1),
+            });
+            continue;
+        }
         const match = (0, string_similarity_js_1.findClosestMatch)(unknownKey, expectedKeys, config.similarityThreshold);
         if (match) {
             suggestions.push({
@@ -43,11 +53,11 @@ function generateMissingRequiredSuggestions(missingKeys, schema, config) {
     suggestions.sort((a, b) => a.param.localeCompare(b.param));
     return suggestions.slice(0, config.maxSuggestions);
 }
-function generateSuggestions(args, schema, config) {
+function generateSuggestions(args, schema, config, aliasMap) {
     const suggestions = [];
     const expectedKeys = (0, schema_introspection_js_1.extractExpectedKeys)(schema);
     const unknownKeys = (0, schema_introspection_js_1.findUnknownKeys)(args, schema);
-    const unknownKeySuggestions = generateUnknownKeySuggestions(unknownKeys, expectedKeys, config);
+    const unknownKeySuggestions = generateUnknownKeySuggestions(unknownKeys, expectedKeys, config, aliasMap);
     suggestions.push(...unknownKeySuggestions);
     const missingKeys = (0, schema_introspection_js_1.findMissingRequiredKeys)(args, schema);
     const missingRequiredSuggestions = generateMissingRequiredSuggestions(missingKeys, schema, config);

package/dist/mcp/workflow-protocol-contracts.d.ts

@@ -0,0 +1,31 @@
+import type { DescriptionMode } from './types/tool-description-types.js';
+export type ProtocolAliasMap = Readonly<Record<string, string>>;
+export interface ProtocolParams {
+    readonly required: readonly string[];
+    readonly optional?: readonly string[];
+}
+export interface CompactDescriptionSpec {
+    readonly purpose: string;
+    readonly whenToUse?: string;
+    readonly rules?: readonly string[];
+    readonly examplePayload?: Readonly<Record<string, unknown>>;
+    readonly returns?: string;
+}
+export interface WorkflowProtocolContract {
+    readonly canonicalParams: ProtocolParams;
+    readonly aliasMap?: ProtocolAliasMap;
+    readonly descriptions: Readonly<Record<DescriptionMode, CompactDescriptionSpec>>;
+}
+export declare const CONTINUE_WORKFLOW_CONTEXT_OBJECT_GUIDANCE = "Set these keys in the next `continue_workflow` call's `context` object:";
+export declare const CONTINUE_WORKFLOW_SINGLE_CONTEXT_OBJECT_GUIDANCE = "Set this key in the next `continue_workflow` call's `context` object:";
+export declare function renderCompactDescription(spec: CompactDescriptionSpec, canonicalParams: ProtocolParams): string;
+export declare function normalizeAliasedFields(value: Readonly<Record<string, unknown>>, aliasMap: ProtocolAliasMap): Record<string, unknown>;
+export declare function findAliasFieldConflicts(value: Readonly<Record<string, unknown>>, aliasMap: ProtocolAliasMap): readonly {
+    alias: string;
+    canonical: string;
+}[];
+export declare const START_WORKFLOW_PROTOCOL: WorkflowProtocolContract;
+export declare const CONTINUE_WORKFLOW_PROTOCOL: WorkflowProtocolContract;
+export declare const CHECKPOINT_WORKFLOW_PROTOCOL: WorkflowProtocolContract;
+export declare const RESUME_SESSION_PROTOCOL: WorkflowProtocolContract;
+export declare function renderProtocolDescription(contract: WorkflowProtocolContract, mode: DescriptionMode): string;