feat: make workflow states dynamic with XState-style statechart config (#147) (#160)

## Summary

Introduces a configurable workflow state machine that replaces all hardcoded
state labels. The default workflow matches current behavior exactly, ensuring
backward compatibility.

## Architecture

### lib/workflow.ts — Core workflow engine

XState-style statechart configuration:

```typescript
type StateConfig = {
  type: 'queue' | 'active' | 'hold' | 'terminal';
  role?: 'dev' | 'qa';
  label: string;
  color: string;
  priority?: number;
  on?: Record<string, TransitionTarget>;
};
```

All behavior is derived from the config:
- Queue states: `type: 'queue'`, grouped by role, ordered by priority
- Active states: `type: 'active'` — worker occupied
- Transitions: defined with optional actions (gitPull, detectPr, closeIssue, reopenIssue)
- Labels and colors: derived from state.label and state.color

### Derivation functions

- `getStateLabels()` — all labels for issue tracker sync
- `getLabelColors()` — label → color mapping
- `getQueueLabels(role)` — queue labels for a role, ordered by priority
- `getActiveLabel(role)` — the active/in-progress label for a role
- `getRevertLabel(role)` — queue label to revert to on failure
- `detectRoleFromLabel()` — detect role from a queue label
- `getCompletionRule(role, result)` — derive transition rule from config

## Files Changed

- **lib/workflow.ts** — NEW: workflow engine and default config
- **lib/providers/provider.ts** — deprecate STATE_LABELS, LABEL_COLORS; derive from workflow
- **lib/providers/github.ts** — use workflow config for label operations
- **lib/providers/gitlab.ts** — use workflow config for label operations
- **lib/services/pipeline.ts** — use getCompletionRule() from workflow
- **lib/services/tick.ts** — use workflow for queue/active labels
- **lib/services/health.ts** — use workflow for active/revert labels
- **lib/tools/work-start.ts** — use workflow for target label

## Backward Compatibility

- DEFAULT_WORKFLOW matches current hardcoded behavior exactly
- Deprecated exports kept for any external consumers
- No breaking changes to tool interfaces or project state

## Future Work

- Load per-project workflow overrides from projects.json
- User-facing config in projects/workflow.json
- Tool schema generation from workflow states

lib/services/pipeline.ts

@@ -1,23 +1,30 @@
 /**
  * Pipeline service — declarative completion rules.
  *
- * Replaces 7 if-blocks with a data-driven lookup table.
+ * Uses workflow config to determine transitions and side effects.
  */
 import type { PluginRuntime } from "openclaw/plugin-sdk";
 import type { StateLabel, IssueProvider } from "../providers/provider.js";
 import { deactivateWorker } from "../projects.js";
 import { runCommand } from "../run-command.js";
 import { notify, getNotificationConfig } from "../notify.js";
+import {
+  DEFAULT_WORKFLOW,
+  getCompletionRule,
+  getNextStateDescription,
+  getCompletionEmoji,
+  type CompletionRule,
+  type WorkflowConfig,
+} from "../workflow.js";
 
-export type CompletionRule = {
-  from: StateLabel;
-  to: StateLabel;
-  gitPull?: boolean;
-  detectPr?: boolean;
-  closeIssue?: boolean;
-  reopenIssue?: boolean;
-};
+// ---------------------------------------------------------------------------
+// Backward compatibility exports
+// ---------------------------------------------------------------------------
 
+/**
+ * @deprecated Use getCompletionRule() from workflow.ts instead.
+ * Kept for backward compatibility.
+ */
 export const COMPLETION_RULES: Record<string, CompletionRule> = {
   "dev:done":    { from: "Doing",   to: "To Test",    gitPull: true, detectPr: true },
   "qa:pass":     { from: "Testing", to: "Done",       closeIssue: true },
@@ -27,6 +34,9 @@ export const COMPLETION_RULES: Record<string, CompletionRule> = {
   "qa:blocked":  { from: "Testing", to: "Refining" },
 };
 
+/**
+ * @deprecated Use getNextStateDescription() from workflow.ts instead.
+ */
 export const NEXT_STATE: Record<string, string> = {
   "dev:done":    "QA queue",
   "dev:blocked": "moved to Refining - needs human input",
@@ -36,14 +46,8 @@ export const NEXT_STATE: Record<string, string> = {
   "qa:blocked":  "moved to Refining - needs human input",
 };
 
-const EMOJI: Record<string, string> = {
-  "dev:done":    "✅",
-  "qa:pass":     "🎉",
-  "qa:fail":     "❌",
-  "qa:refine":   "🤔",
-  "dev:blocked": "🚫",
-  "qa:blocked":  "🚫",
-};
+// Re-export CompletionRule type for backward compatibility
+export type { CompletionRule };
 
 export type CompletionOutput = {
   labelTransition: string;
@@ -55,8 +59,16 @@ export type CompletionOutput = {
   issueReopened?: boolean;
 };
 
-export function getRule(role: string, result: string): CompletionRule | undefined {
-  return COMPLETION_RULES[`${role}:${result}`];
+/**
+ * Get completion rule for a role:result pair.
+ * Uses workflow config when available.
+ */
+export function getRule(
+  role: string,
+  result: string,
+  workflow: WorkflowConfig = DEFAULT_WORKFLOW,
+): CompletionRule | undefined {
+  return getCompletionRule(workflow, role as "dev" | "qa", result) ?? undefined;
 }
 
 /**
@@ -77,10 +89,17 @@ export async function executeCompletion(opts: {
   pluginConfig?: Record<string, unknown>;
   /** Plugin runtime for direct API access (avoids CLI subprocess timeouts) */
   runtime?: PluginRuntime;
+  /** Workflow config (defaults to DEFAULT_WORKFLOW) */
+  workflow?: WorkflowConfig;
 }): Promise<CompletionOutput> {
-  const { workspaceDir, groupId, role, result, issueId, summary, provider, repoPath, projectName, channel, pluginConfig, runtime } = opts;
+  const {
+    workspaceDir, groupId, role, result, issueId, summary, provider,
+    repoPath, projectName, channel, pluginConfig, runtime,
+    workflow = DEFAULT_WORKFLOW,
+  } = opts;
+
   const key = `${role}:${result}`;
-  const rule = COMPLETION_RULES[key];
+  const rule = getCompletionRule(workflow, role, result);
   if (!rule) throw new Error(`No completion rule for ${key}`);
 
   let prUrl = opts.prUrl;
@@ -100,8 +119,10 @@ export async function executeCompletion(opts: {
   // Get issue early (for URL in notification)
   const issue = await provider.getIssue(issueId);
 
+  // Get next state description from workflow
+  const nextState = getNextStateDescription(workflow, role, result);
+
   // Send notification early (before deactivation and label transition which can fail)
-  // This ensures users see the notification even if subsequent steps have issues
   const notifyConfig = getNotificationConfig(pluginConfig);
   notify(
     {
@@ -113,7 +134,7 @@ export async function executeCompletion(opts: {
       role,
       result: result as "done" | "pass" | "fail" | "refine" | "blocked",
       summary,
-      nextState: NEXT_STATE[key],
+      nextState,
     },
     {
       workspaceDir,
@@ -126,25 +147,25 @@ export async function executeCompletion(opts: {
 
   // Deactivate worker + transition label
   await deactivateWorker(workspaceDir, groupId, role);
-  await provider.transitionLabel(issueId, rule.from, rule.to);
+  await provider.transitionLabel(issueId, rule.from as StateLabel, rule.to as StateLabel);
 
   // Close/reopen
   if (rule.closeIssue) await provider.closeIssue(issueId);
   if (rule.reopenIssue) await provider.reopenIssue(issueId);
 
-  // Build announcement
-  const emoji = EMOJI[key] ?? "📋";
+  // Build announcement using workflow-derived emoji
+  const emoji = getCompletionEmoji(role, result);
   const label = key.replace(":", " ").toUpperCase();
   let announcement = `${emoji} ${label} #${issueId}`;
   if (summary) announcement += ` — ${summary}`;
   announcement += `\n📋 Issue: ${issue.web_url}`;
   if (prUrl) announcement += `\n🔗 PR: ${prUrl}`;
-  announcement += `\n${NEXT_STATE[key]}.`;
+  announcement += `\n${nextState}.`;
 
   return {
     labelTransition: `${rule.from} → ${rule.to}`,
     announcement,
-    nextState: NEXT_STATE[key],
+    nextState,
     prUrl,
     issueUrl: issue.web_url,
     issueClosed: rule.closeIssue,