hzl-core 2.0.0 → 2.2.0

package/dist/services/workflow-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-service.d.ts","sourceRoot":"","sources":["../../src/services/workflow-service.ts"],"names":[],"mappings":"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"}

package/dist/services/workflow-service.js

@@ -0,0 +1,664 @@
+import { createHash } from 'node:crypto';
+import { EventType, TaskStatus } from '../events/types.js';
+import { TaskNotFoundError, } from './task-service.js';
+const WORKFLOW_OP_PROCESSING_STALE_MS = 30 * 60 * 1000;
+const WORKFLOW_DEFINITIONS = {
+    start: {
+        name: 'start',
+        description: 'Resume in-progress work for an agent, otherwise claim next eligible task.',
+        supports_auto_op_id: false,
+        args: [
+            { name: '--agent <name>', required: true, description: 'Agent identity to resume/claim for.' },
+            { name: '--project <project>', required: false, description: 'Optional project filter.' },
+            { name: '--tags <csv>', required: false, description: 'Optional required tags filter.' },
+            { name: '--lease <minutes>', required: false, description: 'Optional lease refresh/claim duration.' },
+            {
+                name: '--resume-policy <policy>',
+                required: false,
+                description: 'Resume policy: first | latest | priority.',
+                default: 'priority',
+            },
+            { name: '--op-id <key>', required: false, description: 'Explicit idempotency key for retries.' },
+        ],
+        notes: [
+            '--auto-op-id is intentionally unsupported for start because polling calls may legitimately return different tasks over time.',
+            'Alternates are bounded by others_limit unless explicitly set to all.',
+        ],
+    },
+    handoff: {
+        name: 'handoff',
+        description: 'Complete a source task and create a follow-on task with carried checkpoint context.',
+        supports_auto_op_id: true,
+        args: [
+            { name: '--from <task-id>', required: true, description: 'Source task id.' },
+            { name: '--title <title>', required: true, description: 'Follow-on task title.' },
+            { name: '--project <project>', required: false, description: 'Optional target project.' },
+            { name: '--agent <agent>', required: false, description: 'Optional follow-on assignee.' },
+            { name: '--carry-checkpoints <n>', required: false, description: 'Number of checkpoints to carry.', default: '3' },
+            { name: '--carry-max-chars <n>', required: false, description: 'Maximum carried context chars.', default: '4000' },
+            { name: '--op-id <key>', required: false, description: 'Explicit idempotency key.' },
+            { name: '--auto-op-id', required: false, description: 'Generate deterministic idempotency key from normalized input.' },
+        ],
+        notes: [
+            'Guardrail: requires --agent, --project, or both to avoid accidental implicit queue routing.',
+        ],
+    },
+    delegate: {
+        name: 'delegate',
+        description: 'Create delegated work from a source task, with dependency gating by default.',
+        supports_auto_op_id: true,
+        args: [
+            { name: '--from <task-id>', required: true, description: 'Source task id.' },
+            { name: '--title <title>', required: true, description: 'Delegated task title.' },
+            { name: '--project <project>', required: false, description: 'Optional target project.' },
+            { name: '--agent <agent>', required: false, description: 'Optional delegated assignee.' },
+            { name: '--no-depends', required: false, description: 'Disable default parent->delegated dependency edge.' },
+            { name: '--checkpoint <text>', required: false, description: 'Checkpoint text recorded on source task.' },
+            { name: '--pause-parent', required: false, description: 'Set parent task to blocked when currently in_progress.' },
+            { name: '--op-id <key>', required: false, description: 'Explicit idempotency key.' },
+            { name: '--auto-op-id', required: false, description: 'Generate deterministic idempotency key from normalized input.' },
+        ],
+        notes: [
+            'Default dependency edge provides availability gating; strict blocking requires --pause-parent.',
+        ],
+    },
+};
+export class WorkflowService {
+    cacheDb;
+    eventStore;
+    projectionEngine;
+    taskService;
+    idempotencyDb;
+    constructor(cacheDb, eventStore, projectionEngine, taskService, idempotencyDb) {
+        this.cacheDb = cacheDb;
+        this.eventStore = eventStore;
+        this.projectionEngine = projectionEngine;
+        this.taskService = taskService;
+        this.idempotencyDb = idempotencyDb;
+    }
+    listWorkflows() {
+        return Object.values(WORKFLOW_DEFINITIONS).map((definition) => ({
+            name: definition.name,
+            description: definition.description,
+        }));
+    }
+    showWorkflow(name) {
+        return WORKFLOW_DEFINITIONS[name];
+    }
+    runStart(input) {
+        const resumePolicy = input.resume_policy ?? 'priority';
+        const includeOthers = input.include_others ?? true;
+        const othersLimit = this.normalizeOthersLimit(input.others_limit);
+        if (input.auto_op_id) {
+            throw new Error('--auto-op-id is not supported for workflow run start; use --op-id only for intentional retries.');
+        }
+        return this.withIdempotency('start', {
+            agent: input.agent,
+            project: input.project ?? null,
+            tags: [...(input.tags ?? [])].sort(),
+            lease_minutes: input.lease_minutes ?? null,
+            resume_policy: resumePolicy,
+            include_others: includeOthers,
+            others_limit: othersLimit,
+        }, input.op_id, false, () => {
+            const resumeCandidates = this.getInProgressCandidates({
+                agent: input.agent,
+                project: input.project,
+                tags: input.tags,
+                resume_policy: resumePolicy,
+            });
+            const selectedResume = resumeCandidates[0];
+            if (selectedResume) {
+                let selectedTask = this.taskService.getTaskById(selectedResume.task_id);
+                if (input.lease_minutes !== undefined) {
+                    selectedTask = this.refreshLease(selectedTask, input.agent, input.lease_minutes);
+                }
+                const otherCandidates = resumeCandidates.slice(1).map((task) => this.toTaskView(task));
+                return {
+                    workflow: 'start',
+                    mode: 'resume',
+                    selected: this.toTaskView(selectedTask),
+                    filters: this.buildFilters(input.project, input.tags),
+                    in_progress_count: resumeCandidates.length,
+                    others_total: otherCandidates.length,
+                    others: includeOthers ? this.boundOthers(otherCandidates, othersLimit) : [],
+                };
+            }
+            const claimCandidates = this.taskService.getAvailableTasks({
+                project: input.project,
+                tagsAll: input.tags,
+                leafOnly: true,
+            });
+            let claimedTask = null;
+            let claimedIndex = -1;
+            for (let index = 0; index < claimCandidates.length; index += 1) {
+                const candidate = claimCandidates[index];
+                try {
+                    claimedTask = this.taskService.claimTask(candidate.task_id, {
+                        author: input.agent,
+                        lease_until: input.lease_minutes !== undefined
+                            ? new Date(Date.now() + input.lease_minutes * 60000).toISOString()
+                            : undefined,
+                    });
+                    claimedIndex = index;
+                    break;
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!claimedTask) {
+                return {
+                    workflow: 'start',
+                    mode: 'none',
+                    selected: null,
+                    filters: this.buildFilters(input.project, input.tags),
+                    in_progress_count: 0,
+                    others_total: 0,
+                    others: [],
+                };
+            }
+            const alternatives = claimCandidates
+                .filter((_, index) => index !== claimedIndex)
+                .map((task) => this.toTaskView(this.taskService.getTaskById(task.task_id)));
+            return {
+                workflow: 'start',
+                mode: 'claim_next',
+                selected: this.toTaskView(claimedTask),
+                filters: this.buildFilters(input.project, input.tags),
+                in_progress_count: 0,
+                others_total: alternatives.length,
+                others: includeOthers ? this.boundOthers(alternatives, othersLimit) : [],
+            };
+        });
+    }
+    runHandoff(input) {
+        const carryCheckpoints = input.carry_checkpoints ?? 3;
+        const carryMaxChars = input.carry_max_chars ?? 4000;
+        return this.withIdempotency('handoff', {
+            from_task_id: input.from_task_id,
+            ...(input.auto_op_id
+                ? { from_last_event_id: this.getTaskLastEventId(input.from_task_id) }
+                : {}),
+            title: input.title,
+            project: input.project ?? null,
+            agent: input.agent ?? null,
+            carry_checkpoints: carryCheckpoints,
+            carry_max_chars: carryMaxChars,
+        }, input.op_id, Boolean(input.auto_op_id), () => {
+            const source = this.taskService.getTaskById(input.from_task_id);
+            if (!source) {
+                throw new TaskNotFoundError(input.from_task_id);
+            }
+            if (!input.agent && !input.project) {
+                throw new Error('handoff requires --agent, --project, or both. Omitting --agent creates a pool-routed task - specify --project to define the queue.');
+            }
+            if (source.status !== TaskStatus.InProgress && source.status !== TaskStatus.Blocked) {
+                throw new Error(`Cannot handoff task ${source.task_id}: status is ${source.status}, expected in_progress or blocked.`);
+            }
+            const checkpoints = this.taskService.getCheckpoints(source.task_id);
+            const carried = checkpoints.slice(-Math.max(0, carryCheckpoints));
+            const carriedText = this.buildCarriedCheckpointContext(carried, carryMaxChars);
+            const carriedDescription = this.sliceByBudget(carriedText, Math.min(2500, carryMaxChars));
+            const carriedCheckpointText = this.sliceByBudget(carriedText.length > carriedDescription.length
+                ? carriedText.slice(carriedDescription.length)
+                : carriedText, Math.min(1500, Math.max(0, carryMaxChars - carriedDescription.length)));
+            const targetProject = input.project ?? source.project;
+            const description = carriedDescription
+                ? `Handoff context from ${source.task_id}:\n\n${carriedDescription}`
+                : undefined;
+            const followOnTask = this.taskService.createTask({
+                title: input.title,
+                project: targetProject,
+                description,
+                agent: input.agent,
+                initial_status: TaskStatus.Ready,
+            }, { author: input.author });
+            try {
+                if (carriedCheckpointText) {
+                    this.taskService.addCheckpoint(followOnTask.task_id, `Handoff context from ${source.task_id}`, { text: carriedCheckpointText }, { author: input.author });
+                }
+                // Complete source last so failures earlier do not mark source done without follow-on context.
+                this.taskService.completeTask(source.task_id, { author: input.author });
+            }
+            catch (error) {
+                // Best-effort rollback: archive the follow-on if handoff could not complete end-to-end.
+                try {
+                    this.taskService.archiveTask(followOnTask.task_id, {
+                        author: input.author,
+                        comment: `handoff rollback: ${source.task_id} completion failed`,
+                    });
+                }
+                catch {
+                    // Swallow rollback failure; original error is more actionable.
+                }
+                throw error;
+            }
+            return {
+                workflow: 'handoff',
+                source_task_id: source.task_id,
+                follow_on: this.toTaskView(followOnTask),
+                carried_checkpoint_count: carried.length,
+                carried_chars: carriedText.length,
+            };
+        });
+    }
+    runDelegate(input) {
+        const addDependency = input.depends_on_parent ?? true;
+        return this.withIdempotency('delegate', {
+            from_task_id: input.from_task_id,
+            ...(input.auto_op_id
+                ? { from_last_event_id: this.getTaskLastEventId(input.from_task_id) }
+                : {}),
+            title: input.title,
+            project: input.project ?? null,
+            agent: input.agent ?? null,
+            depends_on_parent: addDependency,
+            checkpoint: input.checkpoint ?? null,
+            pause_parent: Boolean(input.pause_parent),
+        }, input.op_id, Boolean(input.auto_op_id), () => {
+            const source = this.taskService.getTaskById(input.from_task_id);
+            if (!source) {
+                throw new TaskNotFoundError(input.from_task_id);
+            }
+            const delegated = this.taskService.createTask({
+                title: input.title,
+                project: input.project ?? source.project,
+                agent: input.agent,
+                initial_status: TaskStatus.Ready,
+            }, { author: input.author });
+            let dependencyAdded = false;
+            let checkpointAdded = false;
+            let parentPaused = false;
+            try {
+                if (addDependency) {
+                    const depEvent = this.eventStore.append({
+                        task_id: source.task_id,
+                        type: EventType.DependencyAdded,
+                        data: { depends_on_id: delegated.task_id },
+                        author: input.author,
+                    });
+                    this.projectionEngine.applyEvent(depEvent);
+                    dependencyAdded = true;
+                }
+                if (input.checkpoint?.trim()) {
+                    this.taskService.addCheckpoint(source.task_id, 'Delegated follow-on created', {
+                        delegated_task_id: delegated.task_id,
+                        delegated_title: delegated.title,
+                        note: input.checkpoint.trim(),
+                    }, { author: input.author });
+                    checkpointAdded = true;
+                }
+                if (input.pause_parent && source.status === TaskStatus.InProgress) {
+                    this.taskService.blockTask(source.task_id, {
+                        author: input.author,
+                        comment: `Delegated blocking work to ${delegated.task_id}; pause parent until dependency clears.`,
+                    });
+                    parentPaused = true;
+                }
+            }
+            catch (error) {
+                // Best-effort rollback for partial delegate operations.
+                if (parentPaused) {
+                    try {
+                        this.taskService.unblockTask(source.task_id, {
+                            author: input.author,
+                            comment: `delegate rollback: unable to complete delegation to ${delegated.task_id}`,
+                        });
+                    }
+                    catch {
+                        // Ignore rollback failure; preserve original error.
+                    }
+                }
+                if (dependencyAdded) {
+                    try {
+                        const removeDepEvent = this.eventStore.append({
+                            task_id: source.task_id,
+                            type: EventType.DependencyRemoved,
+                            data: { depends_on_id: delegated.task_id },
+                            author: input.author,
+                        });
+                        this.projectionEngine.applyEvent(removeDepEvent);
+                    }
+                    catch {
+                        // Ignore rollback failure; preserve original error.
+                    }
+                }
+                try {
+                    this.taskService.archiveTask(delegated.task_id, {
+                        author: input.author,
+                        comment: `delegate rollback: ${source.task_id}`,
+                    });
+                }
+                catch {
+                    // Ignore rollback failure; preserve original error.
+                }
+                throw error;
+            }
+            return {
+                workflow: 'delegate',
+                source_task_id: source.task_id,
+                delegated: this.toTaskView(delegated),
+                dependency_added: dependencyAdded,
+                checkpoint_added: checkpointAdded,
+                parent_paused: parentPaused,
+            };
+        });
+    }
+    withIdempotency(workflow, inputForHash, explicitOpId, autoOpId, operation) {
+        if (explicitOpId && autoOpId) {
+            throw new Error('Cannot use --op-id and --auto-op-id together.');
+        }
+        const scope = `workflow:${workflow}`;
+        const inputHash = this.hashWorkflowInput(scope, inputForHash);
+        const resolvedOpId = explicitOpId ?? (autoOpId ? this.computeAutoOpId(workflow, inputHash) : undefined);
+        const autoGenerated = Boolean(!explicitOpId && autoOpId && resolvedOpId);
+        const opTable = this.getOpTableInfo();
+        if (resolvedOpId && opTable) {
+            const claimState = this.claimWorkflowOp(opTable, resolvedOpId, workflow, inputHash);
+            if (claimState === 'completed') {
+                const replay = this.loadWorkflowOp(opTable, resolvedOpId);
+                if (replay?.result_payload) {
+                    return {
+                        ...replay.result_payload,
+                        idempotency: {
+                            op_id: resolvedOpId,
+                            scope,
+                            auto_generated: autoGenerated,
+                            replayed: true,
+                            table_available: true,
+                        },
+                    };
+                }
+                throw new Error(`op_id '${resolvedOpId}' is completed but has no cached result.`);
+            }
+            if (claimState === 'processing') {
+                throw new Error(`op_id '${resolvedOpId}' is already processing.`);
+            }
+            try {
+                const result = operation();
+                this.storeWorkflowOpResult(opTable, resolvedOpId, result);
+                return {
+                    ...result,
+                    idempotency: {
+                        op_id: resolvedOpId,
+                        scope,
+                        auto_generated: autoGenerated,
+                        replayed: false,
+                        table_available: true,
+                    },
+                };
+            }
+            catch (error) {
+                this.storeWorkflowOpError(opTable, resolvedOpId, error);
+                throw error;
+            }
+        }
+        const result = operation();
+        return {
+            ...result,
+            idempotency: {
+                op_id: resolvedOpId ?? null,
+                scope,
+                auto_generated: autoGenerated,
+                replayed: false,
+                table_available: Boolean(opTable),
+            },
+        };
+    }
+    getInProgressCandidates(options) {
+        const where = ["status = 'in_progress'", 'agent = ?'];
+        const params = [options.agent];
+        if (options.project) {
+            where.push('project = ?');
+            params.push(options.project);
+        }
+        if (options.tags && options.tags.length > 0) {
+            where.push(`(SELECT COUNT(DISTINCT tt.tag) FROM task_tags tt WHERE tt.task_id = tasks_current.task_id AND tt.tag IN (${options.tags.map(() => '?').join(', ')})) = ?`);
+            params.push(...options.tags, options.tags.length);
+        }
+        const orderBy = this.buildResumeOrder(options.resume_policy);
+        const rows = this.cacheDb
+            .prepare(`
+      SELECT task_id
+      FROM tasks_current
+      WHERE ${where.join(' AND ')}
+      ORDER BY ${orderBy}
+    `)
+            .all(...params);
+        return rows
+            .map((row) => this.taskService.getTaskById(row.task_id))
+            .filter((task) => task !== null);
+    }
+    buildResumeOrder(policy) {
+        if (policy === 'first') {
+            return 'claimed_at ASC, created_at ASC, task_id ASC';
+        }
+        if (policy === 'latest') {
+            return 'claimed_at DESC, updated_at DESC, task_id ASC';
+        }
+        return 'priority DESC, (due_at IS NULL) ASC, due_at ASC, claimed_at ASC, task_id ASC';
+    }
+    refreshLease(task, agent, leaseMinutes) {
+        const leaseUntil = new Date(Date.now() + leaseMinutes * 60000).toISOString();
+        const event = this.eventStore.append({
+            task_id: task.task_id,
+            type: EventType.StatusChanged,
+            data: {
+                from: TaskStatus.InProgress,
+                to: TaskStatus.InProgress,
+                lease_until: leaseUntil,
+                agent,
+            },
+            author: agent,
+        });
+        this.projectionEngine.applyEvent(event);
+        return this.taskService.getTaskById(task.task_id);
+    }
+    toTaskView(task) {
+        return {
+            task_id: task.task_id,
+            title: task.title,
+            project: task.project,
+            status: task.status,
+            priority: task.priority,
+            agent: task.agent,
+            lease_until: task.lease_until,
+        };
+    }
+    boundOthers(tasks, limit) {
+        if (limit === 'all')
+            return tasks;
+        return tasks.slice(0, limit);
+    }
+    normalizeOthersLimit(limit) {
+        if (limit === 'all')
+            return 'all';
+        if (limit === undefined)
+            return 5;
+        return Math.max(0, limit);
+    }
+    buildFilters(project, tags) {
+        return {
+            ...(project ? { project } : {}),
+            ...(tags && tags.length > 0 ? { tags } : {}),
+        };
+    }
+    buildCarriedCheckpointContext(checkpoints, maxChars) {
+        if (checkpoints.length === 0 || maxChars <= 0)
+            return '';
+        const lines = [];
+        for (const checkpoint of checkpoints) {
+            const payload = Object.keys(checkpoint.data).length
+                ? ` ${JSON.stringify(checkpoint.data)}`
+                : '';
+            lines.push(`[${checkpoint.timestamp}] ${checkpoint.name}${payload}`);
+        }
+        return this.sliceByBudget(lines.join('\n'), maxChars);
+    }
+    sliceByBudget(text, maxChars) {
+        if (maxChars <= 0)
+            return '';
+        if (text.length <= maxChars)
+            return text;
+        return `${text.slice(0, Math.max(0, maxChars - 3))}...`;
+    }
+    getTaskLastEventId(taskId) {
+        const row = this.cacheDb
+            .prepare('SELECT last_event_id FROM tasks_current WHERE task_id = ?')
+            .get(taskId);
+        return row?.last_event_id ?? null;
+    }
+    hashWorkflowInput(scope, input) {
+        const canonical = stableStringify({ scope, input });
+        return createHash('sha256').update(canonical).digest('hex');
+    }
+    computeAutoOpId(workflow, inputHash) {
+        const shortHash = inputHash.slice(0, 24);
+        return `wf_${workflow}_${shortHash}`;
+    }
+    getOpTableInfo() {
+        const dbs = this.idempotencyDb && this.idempotencyDb !== this.cacheDb
+            ? [this.idempotencyDb, this.cacheDb]
+            : [this.cacheDb];
+        for (const db of dbs) {
+            const exists = db
+                .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'workflow_ops'")
+                .get();
+            if (exists)
+                return { db };
+        }
+        return null;
+    }
+    loadWorkflowOp(table, opId) {
+        const row = table.db
+            .prepare(`
+        SELECT workflow_name, input_hash, state, updated_at, result_payload, error_payload
+        FROM workflow_ops
+        WHERE op_id = ?
+        LIMIT 1
+      `)
+            .get(opId);
+        if (!row)
+            return null;
+        return {
+            workflow_name: row.workflow_name,
+            input_hash: row.input_hash,
+            state: row.state,
+            updated_at: row.updated_at,
+            result_payload: parseJsonObject(row.result_payload),
+            error_payload: parseJsonObject(row.error_payload),
+        };
+    }
+    claimWorkflowOp(table, opId, workflow, inputHash) {
+        const now = new Date().toISOString();
+        const insertResult = table.db
+            .prepare(`
+        INSERT INTO workflow_ops (op_id, workflow_name, input_hash, state, created_at, updated_at)
+        VALUES (?, ?, ?, 'processing', ?, ?)
+        ON CONFLICT(op_id) DO NOTHING
+      `)
+            .run(opId, workflow, inputHash, now, now);
+        if ((insertResult.changes ?? 0) === 1)
+            return 'claimed';
+        const existing = this.loadWorkflowOp(table, opId);
+        if (!existing)
+            return 'processing';
+        if (existing.workflow_name !== workflow || existing.input_hash !== inputHash) {
+            throw new Error(`op_id '${opId}' was already used with different workflow input.`);
+        }
+        if (existing.state === 'completed')
+            return 'completed';
+        if (existing.state === 'processing') {
+            const updatedAtMs = Date.parse(existing.updated_at);
+            const isStale = Number.isFinite(updatedAtMs) &&
+                Date.now() - updatedAtMs >= WORKFLOW_OP_PROCESSING_STALE_MS;
+            if (!isStale)
+                return 'processing';
+            const staleReclaimResult = table.db
+                .prepare(`
+          UPDATE workflow_ops
+          SET state = 'processing', updated_at = ?, error_payload = NULL
+          WHERE op_id = ? AND state = 'processing' AND updated_at = ?
+        `)
+                .run(now, opId, existing.updated_at);
+            return (staleReclaimResult.changes ?? 0) === 1
+                ? 'claimed'
+                : 'processing';
+        }
+        const reclaimResult = table.db
+            .prepare(`
+        UPDATE workflow_ops
+        SET state = 'processing', updated_at = ?, error_payload = NULL
+        WHERE op_id = ? AND state = 'failed'
+      `)
+            .run(now, opId);
+        return (reclaimResult.changes ?? 0) === 1 ? 'claimed' : 'processing';
+    }
+    storeWorkflowOpResult(table, opId, result) {
+        const now = new Date().toISOString();
+        table.db
+            .prepare(`
+        UPDATE workflow_ops
+        SET state = 'completed',
+            result_payload = ?,
+            error_payload = NULL,
+            updated_at = ?
+        WHERE op_id = ?
+      `)
+            .run(JSON.stringify(result), now, opId);
+    }
+    storeWorkflowOpError(table, opId, error) {
+        const now = new Date().toISOString();
+        const payload = {
+            message: error instanceof Error ? error.message : String(error),
+            name: error instanceof Error ? error.name : 'Error',
+        };
+        table.db
+            .prepare(`
+        UPDATE workflow_ops
+        SET state = 'failed',
+            error_payload = ?,
+            updated_at = ?
+        WHERE op_id = ?
+      `)
+            .run(JSON.stringify(payload), now, opId);
+    }
+}
+function parseJsonObject(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+    }
+    const record = value;
+    const keys = Object.keys(record).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(',')}}`;
+}
+export class UnknownWorkflowError extends Error {
+    constructor(name) {
+        super(`Unknown workflow: ${name}`);
+    }
+}
+export function parseWorkflowName(name) {
+    if (name === 'start' || name === 'handoff' || name === 'delegate') {
+        return name;
+    }
+    throw new UnknownWorkflowError(name);
+}
+//# sourceMappingURL=workflow-service.js.map