minimal-workflow 0.2.2 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minimal-workflow",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Visual editor for minimal-agent workflow YAML files",
   "type": "module",
   "bin": {

package/src/canvas/WorkflowCanvas.tsx

@@ -21,6 +21,8 @@ import { AssertNode } from './nodes/AssertNode.tsx';
 import { PauseNode } from './nodes/PauseNode.tsx';
 import { BranchNode } from './nodes/BranchNode.tsx';
 import { LoopNode } from './nodes/LoopNode.tsx';
+import { ParallelNode } from './nodes/ParallelNode.tsx';
+import { VoteNode } from './nodes/VoteNode.tsx';
 import { SequentialEdge } from './edges/SequentialEdge.tsx';
 import type { StepDef, StepKind } from '../types.ts';
 
@@ -32,6 +34,8 @@ const nodeTypes = {
   pause: PauseNode,
   branch: BranchNode,
   loop: LoopNode,
+  parallel: ParallelNode,
+  vote: VoteNode,
 };
 
 const edgeTypes = {
@@ -175,5 +179,15 @@ function makeStepTemplate(
       return { id, type: 'branch', condition: 'false', then: [], else: [] };
     case 'loop':
       return { id, type: 'loop', over: '[]', as: 'item', do: [] };
+    case 'parallel':
+      return { id, type: 'parallel', fork: [] };
+    case 'vote':
+      return {
+        id,
+        type: 'vote',
+        voters_count: 3,
+        rules: '',
+        input: '${all_findings}',
+      };
   }
 }

package/src/canvas/nodes/ParallelNode.tsx

@@ -0,0 +1,23 @@
+import type { NodeProps } from '@xyflow/react';
+import { BaseNode } from './BaseNode.tsx';
+import type { CanvasNodeData } from '../../types.ts';
+
+/**
+ * ADR-05 parallel 节点：fan-out 多分支 step 并行执行。
+ * 子步骤（fork[]）不暴露为画布 sourceHandle，在 inspector 列表里编辑。
+ * 节点只有默认的 single Bottom source handle（后继 step）+ Top target handle。
+ */
+export function ParallelNode(props: NodeProps) {
+  const data = props.data as CanvasNodeData;
+  const step = data.step;
+  const forkCount = step.fork?.length ?? 0;
+  return (
+    <BaseNode
+      {...props}
+      data={data}
+      variant="parallel"
+      title="⫶ parallel"
+      body={`fork × ${forkCount}（子步骤在 inspector 编辑）`}
+    />
+  );
+}

package/src/canvas/nodes/VoteNode.tsx

@@ -0,0 +1,23 @@
+import type { NodeProps } from '@xyflow/react';
+import { BaseNode } from './BaseNode.tsx';
+import type { CanvasNodeData } from '../../types.ts';
+
+/**
+ * ADR-05 vote 节点：多 voter LLM 评估同一输入，按 threshold 决断保留。
+ * 节点只有默认的 single Bottom source / Top target handle。
+ */
+export function VoteNode(props: NodeProps) {
+  const data = props.data as CanvasNodeData;
+  const step = data.step;
+  const voters = step.voters_count ?? 3;
+  const threshold = step.threshold ?? Math.ceil(voters / 2);
+  return (
+    <BaseNode
+      {...props}
+      data={data}
+      variant="vote"
+      title="⚖ vote"
+      body={`${voters} voters, threshold=${threshold}`}
+    />
+  );
+}

package/src/index.css

@@ -288,6 +288,14 @@ select {
 .canvas-node.loop {
   border-color: #06b6d4;
 }
+.canvas-node.parallel {
+  border-color: #d946ef;
+  background: #fdf4ff;
+}
+.canvas-node.vote {
+  border-color: #ea580c;
+  background: #fff7ed;
+}
 
 /* 文件列表 / 工作流列表（叠在 palette 上方） */
 .file-list {

package/src/inspector/Inspector.tsx

@@ -1,8 +1,9 @@
+import { useState } from 'react';
 import { useWorkflowStore } from '../store/workflowStore.ts';
 import { ToolNodeForm } from './ToolNodeForm.tsx';
 import { LlmNodeForm } from './LlmNodeForm.tsx';
 import { SkillNodeForm } from './SkillNodeForm.tsx';
-import type { StepDef } from '../types.ts';
+import type { StepDef, StepKind } from '../types.ts';
 
 export function Inspector() {
   const selectedId = useWorkflowStore((s) => s.selectedNodeId);
@@ -38,6 +39,8 @@ export function Inspector() {
       {kind === 'pause' && <PauseForm step={step} onPatch={onPatch} />}
       {kind === 'branch' && <BranchForm step={step} onPatch={onPatch} />}
       {kind === 'loop' && <LoopForm step={step} onPatch={onPatch} />}
+      {kind === 'parallel' && <ParallelForm step={step} onPatch={onPatch} />}
+      {kind === 'vote' && <VoteForm step={step} onPatch={onPatch} />}
 
       <CaptureField step={step} onPatch={onPatch} />
 
@@ -222,3 +225,239 @@ function LoopForm({ step, onPatch }: FieldProps) {
     </>
   );
 }
+
+/* ─────────────────────── ADR-05: parallel / vote ─────────────────────── */
+
+/** parallel 节点支持的 fork 子 step 类型（不允许 branch/loop/pause/parallel/vote 嵌套）。 */
+const FORK_CHILD_KINDS: StepKind[] = ['tool', 'llm', 'skill', 'assert'];
+
+function detectChildKind(child: StepDef): StepKind {
+  if (child.type) return child.type;
+  if (child.tool) return 'tool';
+  if (child.skill) return 'skill';
+  if (child.llm) return 'llm';
+  return 'assert';
+}
+
+function ParallelForm({ step, onPatch }: FieldProps) {
+  const fork = step.fork ?? [];
+  const [expanded, setExpanded] = useState<Record<number, boolean>>({});
+
+  const updateForkAt = (i: number, patch: Partial<StepDef>) => {
+    const next = fork.map((s, idx) => (idx === i ? { ...s, ...patch } : s));
+    onPatch({ fork: next });
+  };
+
+  const removeForkAt = (i: number) => {
+    const next = fork.filter((_, idx) => idx !== i);
+    onPatch({ fork: next });
+  };
+
+  const addFork = (kind: StepKind) => {
+    const baseId = nextForkId(fork, kind);
+    let child: StepDef;
+    switch (kind) {
+      case 'tool':
+        child = { id: baseId, tool: 'Read', args: {} };
+        break;
+      case 'llm':
+        child = { id: baseId, llm: '' };
+        break;
+      case 'skill':
+        child = { id: baseId, skill: 'commit', input: '' };
+        break;
+      case 'assert':
+        child = { id: baseId, type: 'assert', condition: 'true', onFail: '' };
+        break;
+      default:
+        return;
+    }
+    onPatch({ fork: [...fork, child] });
+    setExpanded((m) => ({ ...m, [fork.length]: true }));
+  };
+
+  return (
+    <>
+      <div className="field">
+        <label>fork（并行子步骤，{fork.length} 个）</label>
+        <small style={{ color: '#6b7280', fontSize: 11 }}>
+          所有子步骤并发执行；结果聚合后写回当前 step 的 result。子步骤不参与画布连线。
+        </small>
+      </div>
+
+      {fork.map((child, i) => {
+        const childKind = detectChildKind(child);
+        const open = expanded[i] ?? false;
+        return (
+          <div
+            key={i}
+            className="field"
+            style={{
+              border: '1px solid #e5e7eb',
+              borderRadius: 4,
+              padding: 8,
+              marginBottom: 6,
+            }}
+          >
+            <div
+              style={{
+                display: 'flex',
+                gap: 6,
+                alignItems: 'center',
+                justifyContent: 'space-between',
+              }}
+            >
+              <span
+                style={{ cursor: 'pointer', userSelect: 'none', flex: 1 }}
+                onClick={() => setExpanded((m) => ({ ...m, [i]: !open }))}
+              >
+                {open ? '▼' : '▶'}{' '}
+                <code style={{ fontSize: 12 }}>{child.id}</code>
+                <span style={{ color: '#9ca3af', fontSize: 11 }}>
+                  {' '}
+                  · {childKind}
+                </span>
+              </span>
+              <button
+                onClick={() => removeForkAt(i)}
+                style={{
+                  fontSize: 11,
+                  padding: '2px 6px',
+                  background: '#fef2f2',
+                  color: '#dc2626',
+                  border: '1px solid #fca5a5',
+                  borderRadius: 3,
+                }}
+              >
+                ×
+              </button>
+            </div>
+            {open && (
+              <div style={{ marginTop: 6 }}>
+                <div className="field">
+                  <label>id</label>
+                  <input
+                    value={child.id}
+                    onChange={(e) => updateForkAt(i, { id: e.target.value })}
+                  />
+                </div>
+                {childKind === 'tool' && (
+                  <ToolNodeForm
+                    step={child}
+                    onPatch={(p) => updateForkAt(i, p)}
+                  />
+                )}
+                {childKind === 'llm' && (
+                  <LlmNodeForm
+                    step={child}
+                    onPatch={(p) => updateForkAt(i, p)}
+                  />
+                )}
+                {childKind === 'skill' && (
+                  <SkillNodeForm
+                    step={child}
+                    onPatch={(p) => updateForkAt(i, p)}
+                  />
+                )}
+                {childKind === 'assert' && (
+                  <AssertForm
+                    step={child}
+                    onPatch={(p) => updateForkAt(i, p)}
+                  />
+                )}
+              </div>
+            )}
+          </div>
+        );
+      })}
+
+      <div className="field">
+        <label>添加 fork</label>
+        <div style={{ display: 'flex', gap: 4 }}>
+          {FORK_CHILD_KINDS.map((k) => (
+            <button
+              key={k}
+              onClick={() => addFork(k)}
+              style={{ fontSize: 11, padding: '2px 8px' }}
+            >
+              + {k}
+            </button>
+          ))}
+        </div>
+      </div>
+    </>
+  );
+}
+
+function nextForkId(fork: StepDef[], kind: StepKind): string {
+  const taken = new Set(fork.map((s) => s.id));
+  let i = 1;
+  while (taken.has(`${kind}_${i}`)) i++;
+  return `${kind}_${i}`;
+}
+
+function VoteForm({ step, onPatch }: FieldProps) {
+  const voters = step.voters_count ?? 3;
+  const defaultThreshold = Math.ceil(voters / 2);
+  return (
+    <>
+      <div className="field">
+        <label>voters_count（投票 LLM 数量）</label>
+        <input
+          type="number"
+          min={2}
+          max={10}
+          value={voters}
+          onChange={(e) => {
+            const v = Number(e.target.value);
+            if (Number.isFinite(v) && v >= 2 && v <= 10) {
+              onPatch({ voters_count: v });
+            }
+          }}
+        />
+      </div>
+      <div className="field">
+        <label>threshold（通过票数，留空 = 默认）</label>
+        <input
+          type="number"
+          min={1}
+          value={step.threshold ?? ''}
+          placeholder={`默认 Math.ceil(voters_count/2) = ${defaultThreshold}`}
+          onChange={(e) => {
+            const v = e.target.value;
+            if (v === '') {
+              onPatch({ threshold: undefined });
+            } else {
+              const n = Number(v);
+              if (Number.isFinite(n) && n >= 1) onPatch({ threshold: n });
+            }
+          }}
+        />
+      </div>
+      <div className="field">
+        <label>rules（评估规则 prompt）</label>
+        <textarea
+          value={step.rules ?? ''}
+          rows={5}
+          spellCheck={false}
+          placeholder="评估这个 finding 是否值得保留..."
+          onChange={(e) => onPatch({ rules: e.target.value })}
+          style={{ fontFamily: 'ui-monospace, monospace', fontSize: 12 }}
+        />
+      </div>
+      <div className="field">
+        <label>input（要被投票评估的输入）</label>
+        <input
+          value={step.input ?? ''}
+          placeholder="${all_findings}"
+          onChange={(e) =>
+            onPatch({ input: e.target.value === '' ? undefined : e.target.value })
+          }
+        />
+        <small style={{ color: '#6b7280', fontSize: 11 }}>
+          支持 ${'{var}'} 模板；通常引用上游 parallel 的聚合 result
+        </small>
+      </div>
+    </>
+  );
+}

package/src/palette/ControlFlowSection.tsx

@@ -13,6 +13,18 @@ const ITEMS: FlowItem[] = [
   { kind: 'pause', icon: '⏸', label: 'pause', desc: 'HITL 暂停点（非交互模式跳过）' },
   { kind: 'branch', icon: '🔀', label: 'branch', desc: '二选一分支（then / else）' },
   { kind: 'loop', icon: '🔁', label: 'loop', desc: '遍历数组，对每项执行子步' },
+  {
+    kind: 'parallel',
+    icon: '⫶',
+    label: 'parallel',
+    desc: 'fan-out 并行执行多个子步骤（fork 列表在 inspector 编辑）',
+  },
+  {
+    kind: 'vote',
+    icon: '⚖',
+    label: 'vote',
+    desc: '多 voter LLM 评估同一输入，按 threshold 决断',
+  },
 ];
 
 export function ControlFlowSection() {

package/src/store/workflowStore.ts

@@ -115,6 +115,13 @@ export const useWorkflowStore = create<WorkflowState>((set, get) => ({
 
     const flatten = (steps: StepDef[]): void => {
       for (const raw of steps) {
+        // parallel / vote：fork[] / 内部子步骤**不展平**，整个 step 原样作为
+        //   单个 canvas node（子步骤在 inspector 列表内编辑）。
+        if (raw.type === 'parallel' || raw.type === 'vote') {
+          flat.push({ step: raw, childEdges: [] });
+          continue;
+        }
+
         const { then: thenChildren, else: elseChildren, do: doChildren, ...rest } =
           raw;
         const cleaned: StepDef = { ...rest };
@@ -517,6 +524,9 @@ function withChildren(
   step: StepDef,
   children: { then?: StepDef[]; else?: StepDef[]; do?: StepDef[] } | undefined,
 ): StepDef {
+  // ADR-05：parallel / vote 不挂 then/else/do 子步骤，原样返回
+  // （fork / voters_count 等字段已在 step 上）
+  if (step.type === 'parallel' || step.type === 'vote') return step;
   if (!children) return step;
   const out: StepDef = { ...step };
   if (children.then) out.then = children.then;

package/src/types.ts

@@ -10,7 +10,9 @@ export type StepKind =
   | 'assert'
   | 'branch'
   | 'loop'
-  | 'pause';
+  | 'pause'
+  | 'parallel'
+  | 'vote';
 
 export interface WorkflowInput {
   name: string;
@@ -39,6 +41,15 @@ export interface StepDef {
   onError?: 'halt' | 'continue';
   onFail?: string;
   maxTurns?: number;
+
+  // ADR-05 字段（parallel / vote / 通用 LLM 增强）
+  output_schema?: Record<string, unknown>;
+  fork?: StepDef[];
+  voters_count?: number;
+  rules?: string;
+  threshold?: number;
+  context_files?: Array<{ path: string; hint?: string }>;
+  allowed_tools?: string[];
 }
 
 export interface WorkflowEdgeMeta {