@mars.liu/dsh-cybernetics 0.2.0 → 0.6.0

package/lib/client.js

@@ -3,8 +3,13 @@
 // host — no plugin HTTP route needed. Hand-written ModuleLoader wrapper, same
 // format the host bundler emits (see dsh-context / dsh-maze client.js).
 /* global window */
+// Registration id = the package name in package.json, NOT the short plugin row
+// id: the client-modules boot graph keys every row by the package manifest name
+// (`@mars.liu/dsh-cybernetics`) and only materializes a row whose bundle
+// registered under exactly that id — a stale `dsh-cybernetics` here executes
+// the batch script fine, then reports "loaded without registering".
 window.__ModuleLoader__.load({
-	id: 'dsh-cybernetics',
+	id: '@mars.liu/dsh-cybernetics',
 	factory: (require) => {
 		var module = { exports: {} };
 		var exports = module.exports;
@@ -35,6 +40,28 @@ window.__ModuleLoader__.load({
 			'agent.noData': '目标数据未同步',
 			'agents.empty': '本会话当前没有子 agent。',
 			'agents.count': '{running}/{total} 个 agent 运行中',
+			// v0.6 multi-goal projection (`cyberneticsGoals`) — every goal of the
+			// session in one tab, updated in place.
+			'goals.count': '{count} 个目标',
+			'goal.round': '第 {round} 轮',
+			'goal.subgoal': '当前子目标',
+			'goal.depth.quick': '轻量',
+			'goal.depth.full': '完整',
+			'goal.executor.ephemeral': '临时执行者',
+			'goal.executor.persistent': '持久执行者',
+			'goalStatus.pending': '待启动',
+			'goalStatus.running': '进行中',
+			'goalStatus.paused': '已暂停',
+			'goalStatus.met': '已完成',
+			'goalStatus.cancelled': '已取消',
+			'goalStatus.superseded': '已被取代',
+			'goalStatus.failed': '受阻',
+			// v0.6 append-only goal lineage lines (server sets these fields)
+			'goal.supersededBy': '已被「{title}」取代',
+			'goal.revisedFrom': '修订自「{title}」',
+			// v0.6 executor line: the durable teammate's name (persistent only)
+			'goal.member': '成员 {name}',
+			'control.goals': '目标',
 		};
 		const en = {
 			'view.goal': 'Goal',
@@ -57,6 +84,24 @@ window.__ModuleLoader__.load({
 			'agent.noData': 'Goal data not synced',
 			'agents.empty': 'No child agents in this session yet.',
 			'agents.count': '{running}/{total} agents running',
+			'goals.count': '{count} goals',
+			'goal.round': 'round {round}',
+			'goal.subgoal': 'Current subgoal',
+			'goal.depth.quick': 'Quick',
+			'goal.depth.full': 'Full',
+			'goal.executor.ephemeral': 'Ephemeral executor',
+			'goal.executor.persistent': 'Persistent executor',
+			'goalStatus.pending': 'Pending',
+			'goalStatus.running': 'Running',
+			'goalStatus.paused': 'Paused',
+			'goalStatus.met': 'Complete',
+			'goalStatus.cancelled': 'Cancelled',
+			'goalStatus.superseded': 'Superseded',
+			'goalStatus.failed': 'Blocked',
+			'goal.supersededBy': 'Superseded by "{title}"',
+			'goal.revisedFrom': 'Revised from "{title}"',
+			'goal.member': 'Member {name}',
+			'control.goals': 'Goals',
 		};
 		//#endregion
 
@@ -68,12 +113,104 @@ window.__ModuleLoader__.load({
 		};
 
 		//#region goal view component
-		// props.goal: ObservableSnapshot face of the session `goal` projection.
-		// The snapshot may be the raw state ({current: GoalProjection | null, ...})
-		// or the projection value itself — normalize both; undefined = not yet arrived.
-		function GoalView(props) {
+		// v0.6: the tab is driven by the plugin's own `cyberneticsGoals`
+		// projection — the WHOLE multi-goal board of this session, pushed live
+		// by the host (one whole-value `cybernetics/goals` event per change, no
+		// polling). When that key is absent (older plugin/host) or carries an
+		// empty board, fall back to dsh-goal's single-slot `goal` projection,
+		// which is exactly the pre-v0.6 rendering.
+		const GOAL_STATUS_KEY = {
+			pending: 'goalStatus.pending',
+			running: 'goalStatus.running',
+			paused: 'goalStatus.paused',
+			met: 'goalStatus.met',
+			cancelled: 'goalStatus.cancelled',
+			superseded: 'goalStatus.superseded',
+			failed: 'goalStatus.failed',
+		};
+
+		function goalStatusStyle(status) {
+			if (status === 'running') return { color: '#3fb950' };
+			if (status === 'failed') return { color: '#d29922' };
+			if (status === 'met') return { color: '#58a6ff' };
+			return { color: '#8b949e' };
+		}
+
+		// End-of-life statuses: the same two-segment rule the goal tab uses
+		// (unfinished first, finished after). The server already sorts that way;
+		// this stable partition keeps the invariant even if a view arrives with a
+		// different order, without re-sorting anything inside a segment.
+		const COMPLETED_GOAL_STATUSES = ['met', 'cancelled', 'superseded'];
+		function groupGoals(goals) {
+			const open = [];
+			const done = [];
+			for (const g of goals) {
+				if (COMPLETED_GOAL_STATUSES.indexOf(g.status) >= 0) done.push(g);
+				else open.push(g);
+			}
+			return open.concat(done);
+		}
+
+		// One goal row: title + status badge + round + current subgoal + tags.
+		// Append-only lineage (v0.6): a superseded goal names its successor, a
+		// revised goal names where it came from — titles resolved from the board
+		// snapshot, falling back to the goalId when the successor is not listed.
+		function GoalRow(props) {
+			const t = props.t;
+			const g = props.goal;
+			const titles = props.titles || {};
+			const statusKey = GOAL_STATUS_KEY[g.status] ?? 'goalStatus.pending';
+			const depthKey = g.depth === 'quick' ? 'goal.depth.quick' : 'goal.depth.full';
+			const executorKey = g.executor === 'persistent' ? 'goal.executor.persistent' : 'goal.executor.ephemeral';
+			return jsx.jsxs('div', { style: styles.goalCard, children: [
+				jsx.jsxs('div', { style: styles.goalHead, children: [
+					jsx.jsx('span', { style: styles.goalTitle, children: g.title || g.goalId }),
+					jsx.jsx('span', { style: { ...styles.badge, ...goalStatusStyle(g.status) }, children: t(statusKey) }),
+				] }),
+				jsx.jsxs('div', { style: styles.goalMetaRow, children: [
+					jsx.jsx('span', { style: styles.meta, children: t('goal.round', { round: g.round ?? 0 }) }),
+					jsx.jsx('span', { style: styles.tag, children: t(depthKey) }),
+					jsx.jsx('span', { style: styles.tag, children: t(executorKey) }),
+					g.memberName
+						? jsx.jsx('span', { style: styles.tag, children: t('goal.member', { name: g.memberName }) })
+						: null,
+				] }),
+				g.supersededBy
+					? jsx.jsx('div', { style: styles.lineage, children: t('goal.supersededBy', { title: titles[g.supersededBy] || g.supersededBy }) })
+					: null,
+				g.parentGoalId
+					? jsx.jsx('div', { style: styles.lineage, children: t('goal.revisedFrom', { title: titles[g.parentGoalId] || g.parentGoalId }) })
+					: null,
+				g.subgoal
+					? jsx.jsxs('div', { style: styles.goalSubgoal, children: [t('goal.subgoal') + '：', g.subgoal] })
+					: null,
+			] });
+		}
+
+		// Multi-goal list. Order is the projection's (server-side two segments:
+		// unfinished goals first, finished after; newest change first inside each),
+		// so the client renders verbatim and never re-sorts.
+		function GoalsList(props) {
+			const t = props.t;
+			const goals = props.goals;
+			const titles = {};
+			for (const g of goals) titles[g.goalId] = g.title || g.goalId;
+			return jsx.jsxs('div', { style: styles.root, children: [
+				jsx.jsx('div', { style: styles.badgeRow, children:
+					jsx.jsx('span', { style: styles.badge, children: t('goals.count', { count: goals.length }) }) }),
+				...goals.map(function (g) {
+					return jsx.jsx(GoalRow, { goal: g, t: t, titles: titles }, g.goalId + ':' + (g.updatedAt ?? 0));
+				}),
+				jsx.jsx('div', { style: styles.hint, children: t('loopHint') }),
+			] });
+		}
+
+		// props.raw: the session `goal` projection snapshot value. It may be the
+		// raw state ({current: GoalProjection | null, ...}) or the projection
+		// value itself — normalize both; undefined = not yet arrived.
+		function SingleGoalView(props) {
 			const t = props.t;
-			const raw = react.useSyncExternalStore(props.goal.subscribe, props.goal.getSnapshot);
+			const raw = props.raw;
 			if (raw === undefined) return null;
 			const goal = raw !== null && typeof raw === 'object' && 'current' in raw ? raw.current : raw;
 			if (goal === null || goal === undefined) {
@@ -93,6 +230,16 @@ window.__ModuleLoader__.load({
 			] });
 		}
 
+		function GoalView(props) {
+			const goalsRaw = react.useSyncExternalStore(props.goals.subscribe, props.goals.getSnapshot);
+			const singleRaw = react.useSyncExternalStore(props.goal.subscribe, props.goal.getSnapshot);
+			const goals = goalsRaw !== null && typeof goalsRaw === 'object' && Array.isArray(goalsRaw.goals)
+				? goalsRaw.goals
+				: [];
+			if (goals.length > 0) return jsx.jsx(GoalsList, { t: props.t, goals: goals });
+			return jsx.jsx(SingleGoalView, { t: props.t, raw: singleRaw });
+		}
+
 		var styles = {
 			root: { display: 'flex', flexDirection: 'column', gap: 8, padding: '12px 16px', overflow: 'auto' },
 			empty: { padding: '12px 16px', opacity: 0.6 },
@@ -102,6 +249,17 @@ window.__ModuleLoader__.load({
 			blocked: { color: '#d29922', fontSize: 12 },
 			meta: { opacity: 0.65, fontSize: 12 },
 			hint: { opacity: 0.45, fontSize: 11 },
+			// v0.6 multi-goal rows
+			goalCard: { display: 'flex', flexDirection: 'column', gap: 4, padding: '8px 10px', border: '1px solid rgba(127,127,127,0.25)', borderRadius: 6 },
+			goalHead: { display: 'flex', alignItems: 'center', gap: 6, minWidth: 0 },
+			goalTitle: { fontSize: 13, fontWeight: 600, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' },
+			goalMetaRow: { display: 'flex', alignItems: 'center', gap: 6, flexWrap: 'wrap' },
+			tag: { fontSize: 10, padding: '0 6px', borderRadius: 999, border: '1px solid rgba(127,127,127,0.35)', opacity: 0.75 },
+			goalSubgoal: { fontSize: 12, opacity: 0.85, whiteSpace: 'pre-wrap', lineHeight: 1.45 },
+			lineage: { fontSize: 11, opacity: 0.6, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' },
+			// v0.6 control tab executor rows
+			controlGoalRow: { display: 'flex', alignItems: 'center', gap: 6, minWidth: 0, flexWrap: 'wrap', padding: '2px 0' },
+			goalCards: { display: 'flex', flexDirection: 'column', gap: 4, marginBottom: 4 },
 			agentRow: { borderLeft: '2px solid transparent', borderRadius: 4 },
 			agentMain: { display: 'flex', flexDirection: 'column', gap: 2 },
 			agentHead: { display: 'flex', alignItems: 'center', gap: 6, minWidth: 0 },
@@ -122,13 +280,39 @@ window.__ModuleLoader__.load({
 		//#endregion
 
 		//#region control view component
-		// The「控制 / Control」tab: every agent of the current session — the lead
-		// itself plus the subagent catalog (recursively) — with its run state and
-		// its own durable goal (dsh-goal projection values). All reactive input
-		// comes from the session list store, which the Session Controller updates
-		// live via the control stream (running flips, goal/control frames).
+		// The「控制 / Control」tab: every goal of the session with its EXECUTOR
+		// line (substrate + the durable teammate's name when it runs on one),
+		// plus every agent of the current session — the lead itself and the
+		// subagent catalog (recursively) — with its run state and its own durable
+		// goal (dsh-goal projection values). Goal data comes from the same
+		// `cyberneticsGoals` whole-value projection the goal tab reads; the agent
+		// tree comes from the session list store, updated live by the Session
+		// Controller via the control stream (running flips, goal/control frames).
 		const MAX_TREE_DEPTH = 3;
 
+		// No goal face (older host/plugin): keep the agent tree rendering exactly
+		// as before instead of throwing.
+		const NOOP_GOALS_FACE = { subscribe: () => () => {}, getSnapshot: () => undefined };
+
+		// One goal row of the control tab: status + title + executor + durable
+		// member name + round. Same fields as the goal tab, restated as the
+		// operator's line — who is executing this goal and how far it got.
+		function ControlGoalRow(props) {
+			const t = props.t;
+			const g = props.goal;
+			const statusKey = GOAL_STATUS_KEY[g.status] ?? 'goalStatus.pending';
+			const executorKey = g.executor === 'persistent' ? 'goal.executor.persistent' : 'goal.executor.ephemeral';
+			return jsx.jsxs('div', { style: styles.controlGoalRow, children: [
+				jsx.jsx('span', { style: { ...styles.badge, ...goalStatusStyle(g.status) }, children: t(statusKey) }),
+				jsx.jsx('span', { style: styles.agentName, children: g.title || g.goalId }),
+				jsx.jsx('span', { style: styles.tag, children: t(executorKey) }),
+				g.memberName
+					? jsx.jsx('span', { style: styles.tag, children: t('goal.member', { name: g.memberName }) })
+					: null,
+				jsx.jsx('span', { style: styles.meta, children: t('goal.round', { round: g.round ?? 0 }) }),
+			] });
+		}
+
 		/** Depth-first agent rows rooted at `rootId`: lead + subagentCatalog, recursed. */
 		function collectAgents(list, rootId) {
 			const rows = [];
@@ -184,9 +368,23 @@ window.__ModuleLoader__.load({
 			const t = props.t;
 			const sessions = props.sessions;
 			const list = react.useSyncExternalStore(sessions.list.subscribe, sessions.list.getSnapshot);
+			const goalsFace = props.goals ?? NOOP_GOALS_FACE;
+			const goalsRaw = react.useSyncExternalStore(goalsFace.subscribe, goalsFace.getSnapshot);
+			const goals = goalsRaw !== null && typeof goalsRaw === 'object' && Array.isArray(goalsRaw.goals)
+				? groupGoals(goalsRaw.goals)
+				: [];
 			const agents = collectAgents(list, props.sessionId);
 			const runningCount = agents.filter((a) => a.running).length;
 			return jsx.jsxs('div', { style: styles.root, children: [
+				goals.length > 0
+					? jsx.jsxs('div', { style: styles.goalCards, children: [
+						jsx.jsxs('div', { style: styles.badgeRow, children: [
+							jsx.jsx('span', { style: styles.meta, children: t('control.goals') }),
+							jsx.jsx('span', { style: styles.badge, children: t('goals.count', { count: goals.length }) }),
+						] }),
+						...goals.map((g) => jsx.jsx(ControlGoalRow, { goal: g, t }, 'goal:' + g.goalId + ':' + (g.updatedAt ?? 0))),
+					] })
+					: null,
 				jsx.jsxs('div', { style: styles.badgeRow, children: [
 					jsx.jsx('span', { style: styles.badge, children: t('agents.count', { total: agents.length, running: runningCount }) }),
 				] }),
@@ -218,19 +416,39 @@ window.__ModuleLoader__.load({
 				inject: (sessionId) => {
 					const binding = ctx.sessions.binding(sessionId);
 					if (binding === undefined) throw new Error('dsh-cybernetics: session "' + sessionId + '" unavailable');
-					return { goal: binding.session.projections.faceOf('goal') };
+					// v0.6: both faces. `cyberneticsGoals` carries the whole goal
+					// board (live, pushed by the host); `goal` stays as the
+					// backward-compatible fallback for older plugin/host builds.
+					return {
+						goals: binding.session.projections.faceOf('cyberneticsGoals'),
+						goal: binding.session.projections.faceOf('goal'),
+					};
 				},
 			}, GoalView));
 
 			// Control tab: goals + run states of every agent in this session,
 			// driven by the session list store (live via the control stream).
+			// The goal face is optional (older host/plugin): the agent tree then
+			// renders exactly as before.
 			ctx.slots.inject('conversation.view', () => ctx.slots.register({
 				name: 'conversation.view',
 				id: 'cybernetics-control',
 				order: 16,
 				locale: NS,
 				label: () => t('view.control'),
-				inject: (sessionId) => ({ sessionId, sessions: ctx.sessions }),
+				inject: (sessionId) => {
+					let goals = NOOP_GOALS_FACE;
+					try {
+						const binding = ctx.sessions.binding(sessionId);
+						const face = binding && binding.session && binding.session.projections
+							? binding.session.projections.faceOf('cyberneticsGoals')
+							: undefined;
+						if (face) goals = face;
+					} catch {
+						// No multi-goal projection: keep the control tab's agent tree.
+					}
+					return { sessionId, sessions: ctx.sessions, goals };
+				},
 			}, ControlView));
 		}
 		//#endregion

package/package.json

@@ -1,7 +1,16 @@
 {
   "name": "@mars.liu/dsh-cybernetics",
-  "version": "0.2.0",
+  "version": "0.6.0",
   "private": false,
+  "files": [
+    "src",
+    "lib",
+    "workflows",
+    "docs",
+    "locale",
+    "cordis.patch.yml",
+    "README.md"
+  ],
   "description": "Cybernetic work protocol for DSH: the session goal (dsh-goal) driven loop of task -> verify -> triage agents, implicitly advanced via one workflow run per round. Server plugin + client goal tab.",
   "type": "module",
   "main": "src/index.ts",
@@ -29,5 +38,8 @@
       "platform": "web",
       "immediately": true
     }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-session": "*"
   }
 }

package/src/controller.ts

@@ -22,6 +22,8 @@ export interface RoundResult {
   verdict?: unknown
   triage?: unknown
   failed?: string
+  /** Execution substrate used for this round (v0.6 audit). */
+  executor?: 'ephemeral' | 'persistent'
 }
 
 /** LLM target overrides for one sub-agent role; workflow `agent()` opts subset. */
@@ -70,9 +72,60 @@ export interface LoopState {
   role: string
   /** Detailed per-round work order extracted by the calling model; passed to the task agent verbatim. */
   brief?: string
-  /** Lifecycle: running (a round in flight) / paused / met (verify passed, awaits user) / cancelled. */
-  status?: 'running' | 'paused' | 'met' | 'cancelled'
+  /** Round depth: 'quick' = task agent only (lightweight analysis); 'full' = task→verify→triage (default). */
+  depth?: 'quick' | 'full'
+  /** Execution substrate: 'ephemeral' (workflow subagents, default) or 'persistent' (Agent Teams teammate). */
+  executor?: 'ephemeral' | 'persistent'
+  /** Persistent teammate name, set on the first persistent round and reused afterwards. */
+  memberName?: string
+  /**
+   * Lifecycle: running (a round in flight) / paused / met (verify passed, awaits
+   * user) / cancelled / superseded (a revision created a successor goal; this
+   * goal keeps its final state and is never driven again).
+   */
+  status?: 'running' | 'paused' | 'met' | 'cancelled' | 'superseded'
   paused?: { reason: ResumableReason; note: string }
+  /**
+   * Append-only goal lineage (v0.6, user 2026-11-02): a revision never edits the
+   * objective in place — it creates a NEW goal, and the old one keeps its final
+   * state. `parentGoalId` = the goal this one was revised from.
+   */
+  parentGoalId?: string
+  /** Set on a superseded goal: the id of the successor that replaced it. */
+  supersededBy?: string
+  /**
+   * In-place revision log kept for wire compatibility (pre-append-only shape).
+   * v0.6 append-only model: a revision creates a successor goal instead, so new
+   * revisions are recorded as `parentGoalId`/`supersededBy` plus the
+   * `.cybernetics/revisions-<newGoalId>.jsonl` audit line, and this stays empty.
+   */
+  revisions?: Array<{ version: number; reason: string; at: number }>
+}
+
+/** One `revise` transition as written to `.cybernetics/revisions-<newGoalId>.jsonl`. */
+export interface GoalRevisionRecord {
+  /** Superseded goal id. */
+  from: string
+  /** Newly created successor goal id. */
+  to: string
+  /** Why the goal changed (required on the `revise` action). */
+  reason: string
+  /** Epoch milliseconds of the revision. */
+  at: number
+}
+
+/** Input for the append-only goal creation path. */
+export interface GoalSeed {
+  goalId: string
+  title?: string
+  /** Overrides the inherited objective when present. */
+  objective?: string
+  /** Goal this one was revised from (lineage link). */
+  parentGoalId?: string
+  depth?: 'quick' | 'full'
+  executor?: 'ephemeral' | 'persistent'
+  role?: string
+  subgoal?: string
 }
 
 /** Append one round's structured result to the per-workspace audit log. */
@@ -85,6 +138,60 @@ async function writeRoundLog(root: string, goalId: string | undefined, round: nu
   await writeFile(join(root, STATE_DIR, `round-${slug}-${round}.json`), JSON.stringify(result, null, 2))
 }
 
+/**
+ * Append one revision line to `.cybernetics/revisions-<newGoalId>.jsonl`.
+ * One line per transition, so a revision chain is readable (and greppable)
+ * without reconstructing it from per-goal fields. The directory is created
+ * lazily; the caller treats a write failure as non-fatal (see `revise`).
+ */
+export async function writeRevisionLog(root: string, newGoalId: string, record: GoalRevisionRecord): Promise<string> {
+  await mkdir(join(root, STATE_DIR), { recursive: true })
+  const slug = newGoalId.replace(/[^a-zA-Z0-9._-]/g, '_')
+  const file = join(root, STATE_DIR, `revisions-${slug}.jsonl`)
+  await writeFile(file, `${JSON.stringify(record)}\n`, { flag: 'a' })
+  return file
+}
+
+/**
+ * Build the successor goal of an append-only revision. Everything the old goal
+ * owned that is not per-round state — title, objective, depth, executor, role —
+ * is inherited unless a seed field overrides it; the new goal starts at round 0
+ * and carries `parentGoalId`. Pure: it neither mutates nor registers anything.
+ */
+export function createGoal(previous: LoopState | undefined, seed: GoalSeed): LoopState {
+  const objective = seed.objective ?? previous?.objective ?? previous?.title ?? ''
+  const title = seed.title ?? previous?.title ?? objective.split('\n')[0].slice(0, 60)
+  const goal: LoopState = {
+    goalId: seed.goalId,
+    title,
+    objective,
+    round: 0,
+    doneSummary: '',
+    subgoal: seed.subgoal ?? (objective.length > 0 ? objective : title),
+    role: seed.role ?? previous?.role ?? 'default',
+    status: 'running',
+  }
+  const depth = seed.depth ?? previous?.depth
+  if (depth !== undefined) goal.depth = depth
+  const executor = seed.executor ?? previous?.executor
+  if (executor !== undefined) goal.executor = executor
+  const parentGoalId = seed.parentGoalId ?? previous?.goalId
+  if (parentGoalId !== undefined) goal.parentGoalId = parentGoalId
+  return goal
+}
+
+/**
+ * Freeze a goal as superseded by a successor. Mutates the loop in place (the
+ * registry holds the same object); the paused marker is dropped so the view
+ * does not mix "awaiting human" with "replaced".
+ */
+export function supersedeGoal(previous: LoopState, newGoalId: string): LoopState {
+  previous.status = 'superseded'
+  previous.supersededBy = newGoalId
+  previous.paused = undefined
+  return previous
+}
+
 /**
  * Start one round's workflow run without awaiting it. Returns the round
  * number and the live run; the caller either awaits `run.result` itself
@@ -109,6 +216,7 @@ export async function startRound(
       state: { round, doneSummary: state.doneSummary },
       subgoal: state.subgoal,
       brief: state.brief,
+      depth: state.depth ?? 'full',
       role: state.role,
       roles: config.roles ?? {},
     },
@@ -137,7 +245,9 @@ export async function foldRound(
   } else {
     result = settled.value as RoundResult
   }
-  await writeRoundLog(root, state.goalId, round, result)
+  // v0.6 audit: record which substrate ran the round.
+  const logged: RoundResult = { ...result, executor: state.executor ?? 'ephemeral' }
+  await writeRoundLog(root, state.goalId, round, logged)
   return { result, decision: decide(result, state, config) }
 }