@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7194.1.ab4fc81f82

package/src/modules/workflows/lib/step-presentation.ts

@@ -0,0 +1,295 @@
+/**
+ * Step presentation model (spec `2026-07-30-workflow-run-outcomes.md`, Part 2) — PURE.
+ *
+ * The canvas used to paint the ENGINE's lifecycle vocabulary, which was built
+ * for control flow rather than for reading. `WAITING_FOR_ACTIVITIES` means "the
+ * executor handed work to a queue and will resume when it returns" — that is the
+ * engine WORKING, and painting it as an amber pause was the single most
+ * misleading thing on the run views.
+ *
+ * The rule this module encodes: **amber means blocked on the outside world. If
+ * the system is doing work it is blue and it moves.**
+ *
+ * Derived, never stored. No new column, no new engine event: every input is
+ * either a `StepInstance` row, a `WorkflowEvent` row, the instance status or the
+ * engine-owned `metadata.attention` marker. `lib/run-execution.ts` collects the
+ * evidence; this decides what it MEANS. No React, no ORM, no DI — the same rule
+ * `lib/node-outcome-rows.ts` and `lib/breach-routing.ts` follow.
+ */
+
+import type { RunExecution, StepWaitEvidence } from './run-execution'
+import type { WorkflowStatus } from './status-colors'
+
+export type StepPresentationState =
+  /** The system is doing something right now. Blue, and it moves. */
+  | 'working'
+  /** Blocked on something OUTSIDE the system: a person, a timer, a signal. */
+  | 'waiting'
+  /** Parked in the failure queue or breached. Needs a human, unusually. */
+  | 'attention'
+  | 'completed'
+  | 'failed'
+  | 'skipped'
+  | 'not_started'
+
+/**
+ * A translation descriptor rather than a string: this module is pure and has no
+ * `useT`, and the caller is the only one that knows the viewer's locale.
+ */
+export type StepReason = {
+  key: string
+  fallback: string
+  params?: Record<string, string | number>
+}
+
+export type StepPresentation = {
+  state: StepPresentationState
+  /** One line saying what the step is doing or waiting for. */
+  reason: StepReason | null
+  /**
+   * When the CURRENT attempt began, so a working step can say "running for 4m".
+   * `StepInstance.startedAt` already carries it, hence the spec's "it is free".
+   */
+  startedAt: Date | null
+  /** Whether this state deserves motion. Motion is still gated on `prefers-reduced-motion`. */
+  animated: boolean
+}
+
+/**
+ * Instance statuses in which the ENGINE is working, whatever the step row says.
+ *
+ * - `WAITING_FOR_ACTIVITIES` — an async activity is executing in a worker.
+ * - `FORKED` — `openFork` wrote the branch rows and `advanceBranches` drives
+ *   them on the executor loop's next iteration. `FORK` is the one `waitReason`
+ *   the engine itself does not treat as a park (`lib/transition-handler.ts`
+ *   excludes it from `stepPaused`), and it is not an external park here either.
+ * - `COMPENSATING` — the saga is unwinding, which is work.
+ */
+const WORKING_INSTANCE_STATUSES = new Set(['WAITING_FOR_ACTIVITIES', 'FORKED', 'COMPENSATING'])
+
+const TERMINAL_STEP_STATUSES = new Set(['completed', 'failed', 'skipped'])
+
+export type StepPresentationOptions = {
+  /**
+   * Agent id → author-facing label, from the OPTIONAL `agent_orchestrator`
+   * peer's registry. Use the agent's LABEL, never its definition key — an
+   * existing rule in this module. Absent (peer not installed, request failed)
+   * degrades to the id rather than inventing a name.
+   */
+  agentLabels?: ReadonlyMap<string, string>
+  /** The `INVOKE_AGENT` activity's configured agent id, read off the node. */
+  agentId?: string | null
+  /** Child-workflow label for the sub-workflow line, when the caller knows one. */
+  childWorkflowLabel?: string | null
+}
+
+function agentName(
+  agentId: string | null | undefined,
+  options: StepPresentationOptions,
+): string | null {
+  const id = agentId ?? options.agentId ?? null
+  if (!id) return null
+  return options.agentLabels?.get(id) ?? id
+}
+
+function reasonFromEvidence(
+  evidence: StepWaitEvidence,
+  options: StepPresentationOptions,
+): { state: StepPresentationState; reason: StepReason } {
+  switch (evidence.kind) {
+    case 'asyncActivity':
+      return {
+        state: 'working',
+        reason: evidence.activityName
+          ? { key: 'workflows.runState.reason.activityRunning', fallback: 'Running {activity}…', params: { activity: evidence.activityName } }
+          : { key: 'workflows.runState.reason.activityRunningUnnamed', fallback: 'Running an activity…' },
+      }
+    case 'agentRunning': {
+      // THE reported bug: an agent executing in its own worker is the system
+      // working, and it used to paint the same amber pause as a task nobody has
+      // opened since Tuesday.
+      const agent = agentName(evidence.agentId, options)
+      return {
+        state: 'working',
+        reason: agent
+          ? { key: 'workflows.runState.reason.agentRunning', fallback: 'Agent {agent} is running…', params: { agent } }
+          : { key: 'workflows.runState.reason.agentRunningUnnamed', fallback: 'An agent is running…' },
+      }
+    }
+    case 'agentDisposition':
+      return {
+        state: 'waiting',
+        reason: { key: 'workflows.runState.reason.agentDisposition', fallback: 'Waiting for a decision on the proposal' },
+      }
+    case 'subWorkflow': {
+      // A running child IS the system working (spec's Working row), even though
+      // the line says what it is waiting on.
+      const child = options.childWorkflowLabel ?? evidence.childInstanceId
+      return {
+        state: 'working',
+        reason: child
+          ? { key: 'workflows.runState.reason.subWorkflow', fallback: 'Waiting for {workflow}', params: { workflow: child } }
+          : { key: 'workflows.runState.reason.subWorkflowUnnamed', fallback: 'Waiting for a child workflow' },
+      }
+    }
+    case 'signal':
+      return {
+        state: 'waiting',
+        reason: evidence.signalName
+          ? { key: 'workflows.runState.reason.signal', fallback: 'Waiting for signal {signal}', params: { signal: evidence.signalName } }
+          : { key: 'workflows.runState.reason.signalUnnamed', fallback: 'Waiting for a signal' },
+      }
+    case 'timer':
+      return {
+        state: 'waiting',
+        reason: evidence.fireAt
+          ? { key: 'workflows.runState.reason.timer', fallback: 'Waiting until {time}', params: { time: evidence.fireAt.toLocaleString() } }
+          : { key: 'workflows.runState.reason.timerUnnamed', fallback: 'Waiting for a timer' },
+      }
+    case 'condition':
+      return {
+        state: 'waiting',
+        reason: evidence.deadlineAt
+          ? { key: 'workflows.runState.reason.conditionUntil', fallback: 'Waiting for a condition, until {time}', params: { time: evidence.deadlineAt.toLocaleString() } }
+          : { key: 'workflows.runState.reason.condition', fallback: 'Waiting for a condition' },
+      }
+    case 'userTask':
+      // The role queue is definition data every viewer of the run already reads
+      // off the canvas. An individual assignee is NEVER named here: §6.4 owns
+      // that decision, and the run APIs expose an opaque user id with no display
+      // name, so there is nothing honest to render anyway.
+      return {
+        state: 'waiting',
+        reason: evidence.roleQueue
+          ? { key: 'workflows.runState.reason.userTaskQueue', fallback: 'Waiting for {queue}', params: { queue: evidence.roleQueue } }
+          : evidence.hasAssignee
+            ? { key: 'workflows.runState.reason.userTaskAssignee', fallback: 'Waiting for the assignee' }
+            : { key: 'workflows.runState.reason.userTask', fallback: 'Waiting for a person' },
+      }
+    case 'fork': {
+      const running = Math.max(evidence.branchTotal - evidence.branchesSettled, 0)
+      return {
+        state: 'working',
+        reason: {
+          key: 'workflows.runState.reason.fork',
+          fallback: '{running} of {total} branches still running',
+          params: { running, total: evidence.branchTotal },
+        },
+      }
+    }
+  }
+}
+
+/**
+ * Resolve the presentation for one node of the run graph.
+ *
+ * `status` is the already-resolved `StepRunStatus` for the node (from
+ * `resolveNodeRunStatus`), which keeps the START/END conventions in one place.
+ */
+export function resolveStepPresentation(
+  execution: RunExecution,
+  node: { id: string; status: string },
+  options: StepPresentationOptions = {},
+): StepPresentation {
+  const state = execution.stepStates.get(node.id) ?? null
+  const startedAt = state?.startedAt ?? null
+
+  if (TERMINAL_STEP_STATUSES.has(node.status)) {
+    return { state: node.status as StepPresentationState, reason: null, startedAt, animated: false }
+  }
+  if (node.status === 'pending') {
+    return { state: 'not_started', reason: null, startedAt: null, animated: false }
+  }
+
+  const isCurrentStep = execution.currentStepId === node.id
+
+  // Attention outranks everything non-terminal: it is the one state that says
+  // "a human is needed, and not in the ordinary way".
+  if (execution.attention && isCurrentStep) {
+    return {
+      state: 'attention',
+      reason: { key: 'workflows.runState.reason.attention', fallback: 'Parked for attention' },
+      startedAt,
+      animated: false,
+    }
+  }
+
+  const evidence = execution.waits.get(node.id)
+  if (evidence) {
+    const resolved = reasonFromEvidence(evidence, options)
+    return {
+      state: resolved.state,
+      reason: resolved.reason,
+      startedAt,
+      animated: resolved.state === 'working',
+    }
+  }
+
+  // No park evidence, so the instance status is the next-best witness. A queue
+  // hand-off, a fork or a compensation pass are the engine WORKING; anything
+  // else that parked the step is a wait we simply cannot name, and saying
+  // nothing is better than guessing a reason.
+  const instanceStatus = execution.instanceStatus ?? null
+  if (instanceStatus && WORKING_INSTANCE_STATUSES.has(instanceStatus)) {
+    return { state: 'working', reason: null, startedAt, animated: true }
+  }
+  // `node.status === 'paused'` is `applyLiveInstanceStatus` reporting that the
+  // engine parked THIS step. Without evidence there is nothing to name, but the
+  // park itself is real, so it is amber rather than optimistically blue.
+  if (node.status === 'paused') {
+    return { state: 'waiting', reason: null, startedAt, animated: false }
+  }
+  return { state: 'working', reason: null, startedAt, animated: true }
+}
+
+/**
+ * The `INVOKE_AGENT` agent id as the canvas carries it. `invokeAgent` nodes hold
+ * it either directly (the editor's display field) or inside the single
+ * INVOKE_AGENT activity they compile to — `InvokeAgentNode` resolves it the same
+ * two ways, so the reason line reads the same value the card already shows.
+ */
+export function readNodeAgentId(data: unknown): string | null {
+  if (!data || typeof data !== 'object') return null
+  const record = data as Record<string, unknown>
+  if (typeof record.agentId === 'string' && record.agentId.length > 0) return record.agentId
+  const activities = record.activities
+  if (!Array.isArray(activities)) return null
+  for (const activity of activities) {
+    if (!activity || typeof activity !== 'object') continue
+    const entry = activity as Record<string, unknown>
+    if (entry.activityType !== 'INVOKE_AGENT') continue
+    const config = entry.config
+    if (!config || typeof config !== 'object') continue
+    const agentId = (config as Record<string, unknown>).agentId
+    if (typeof agentId === 'string' && agentId.length > 0) return agentId
+  }
+  return null
+}
+
+/**
+ * Map a presentation state onto the canvas paint vocabulary. Kept separate from
+ * the resolver so the decision stays testable without a colour table, and so a
+ * surface that paints differently (a list badge, a timeline bar) can reuse the
+ * same states.
+ */
+export function presentationToWorkflowStatus(state: StepPresentationState): WorkflowStatus {
+  switch (state) {
+    case 'working':
+      return 'working'
+    case 'waiting':
+      return 'waiting'
+    case 'attention':
+      return 'needs_attention'
+    case 'completed':
+      return 'completed'
+    case 'failed':
+      return 'failed'
+    // Deliberately unchanged: `toWorkflowStatus` has always painted a skipped
+    // step as the resting state, and repainting it belongs to Part 1's verdict
+    // work, not to the working-vs-waiting split.
+    case 'skipped':
+      return 'not_started'
+    case 'not_started':
+      return 'not_started'
+  }
+}

package/src/modules/workflows/lib/step-through.ts

@@ -0,0 +1,71 @@
+/**
+ * Workflows Module — Step-through (spec section 8.2)
+ *
+ * *"Pause at each step on test runs — inspect context, continue/abort, canvas
+ * highlights the active node."*
+ *
+ * Deliberately implemented as an INSTANCE-level `PAUSED` between steps, using
+ * the existing status and an engine-owned metadata marker — the same shape the
+ * `failureQueue` directive already uses. It introduces NO new instance status
+ * and NO new step status, so the workflow and step state machines are untouched
+ * (`AGENTS.md` Ask-First).
+ *
+ * The marker is a RELEASE TOKEN, not a "paused" boolean: the author releases one
+ * named step, the engine runs exactly that step, and the cursor landing anywhere
+ * else pauses again. That makes the decision idempotent — replaying
+ * `executeWorkflow` after a crash cannot run a step the author never released,
+ * and a double-click on Continue cannot run two steps.
+ *
+ * PURE: no ORM, no DI, no React.
+ */
+
+export type WorkflowInstanceStepThrough = {
+  enabled: true
+  /**
+   * The one step the author has authorised to run. `null`/absent means the
+   * engine is parked before the current step and waiting for a Continue.
+   */
+  releaseStepId?: string | null
+}
+
+type StepThroughAwareInstance = {
+  metadata?: { stepThrough?: WorkflowInstanceStepThrough | null } | null
+  currentStepId?: string | null
+}
+
+export function isStepThroughArmed(instance: StepThroughAwareInstance | null | undefined): boolean {
+  return instance?.metadata?.stepThrough?.enabled === true
+}
+
+/**
+ * Should the engine stop before executing `stepId`?
+ *
+ * END is deliberately exempt: it executes nothing, and holding a run one click
+ * short of COMPLETED would leave every finished step-through looking parked.
+ */
+export function shouldPauseForStepThrough(
+  instance: StepThroughAwareInstance | null | undefined,
+  stepId: string | null | undefined,
+  stepType: string | null | undefined,
+): boolean {
+  if (!isStepThroughArmed(instance)) return false
+  if (stepType === 'END') return false
+  if (!stepId) return false
+  return instance?.metadata?.stepThrough?.releaseStepId !== stepId
+}
+
+/**
+ * Consume the release token once the released step has been entered, so the
+ * NEXT step pauses again. Returns the marker to persist.
+ */
+export function consumeStepThroughRelease(): WorkflowInstanceStepThrough {
+  return { enabled: true, releaseStepId: null }
+}
+
+/** Authorise exactly `stepId` to run. */
+export function releaseStepThrough(stepId: string): WorkflowInstanceStepThrough {
+  return { enabled: true, releaseStepId: stepId }
+}
+
+export const STEP_THROUGH_EVENT_TYPE = 'STEP_THROUGH_PAUSED'
+export const STEP_THROUGH_RELEASED_EVENT_TYPE = 'STEP_THROUGH_RELEASED'

package/src/modules/workflows/lib/step-type-conversion.ts

@@ -0,0 +1,263 @@
+/**
+ * In-place step type conversion (spec section 4.5, issue #4237 A9a).
+ *
+ * "Change type…" keeps the step's id, name, position and wiring; config the
+ * target type genuinely shares is mapped across, and config it cannot execute
+ * is quarantined under `unmappedConfig` — visible in the inspector, flagged in
+ * Problems, never dropped. Restoring a quarantined value is a matter of
+ * converting back, which is exactly why nothing may be discarded here.
+ *
+ * PURE: plain step data in, plain step data out. No React, no ORM, no DI, no
+ * xyflow. The editor page owns the actual node mutation.
+ *
+ * The vocabulary is the editor's node types rather than the definition's
+ * `stepType` enum, because that is the granularity an author changes: an
+ * `invokeAgent` node compiles to an AUTOMATED step, and converting between the
+ * two is a real, meaningful conversion the enum cannot express.
+ */
+
+export type ConvertibleStepType =
+  | 'userTask'
+  | 'automated'
+  | 'invokeAgent'
+  | 'subWorkflow'
+  | 'waitForSignal'
+  | 'waitForTimer'
+  | 'waitForCondition'
+  | 'parallelFork'
+  | 'parallelJoin'
+  | 'ifElse'
+  | 'switch'
+
+/**
+ * START and END are deliberately absent: `validateWorkflowGraph` requires
+ * exactly one START and at least one END, so converting either one (or into
+ * one) breaks an invariant the author cannot see from the inspector.
+ */
+export const CONVERTIBLE_STEP_TYPES: ConvertibleStepType[] = [
+  'userTask',
+  'automated',
+  'invokeAgent',
+  'subWorkflow',
+  'waitForSignal',
+  'waitForTimer',
+  'waitForCondition',
+  'ifElse',
+  'switch',
+  'parallelFork',
+  'parallelJoin',
+]
+
+/** Step data that describes the step itself, never a single type's behaviour. */
+const SHARED_DATA_KEYS = [
+  'label',
+  'stepName',
+  'description',
+  'timeout',
+  'retryPolicy',
+  'errorDirective',
+  'status',
+  'stepNumber',
+  'stepMetadata',
+] as const
+
+/** Top-level `node.data` keys each type actually executes. */
+const TYPE_DATA_KEYS: Record<ConvertibleStepType, readonly string[]> = {
+  userTask: ['assignedTo', 'assignedToRoles', 'formKey', 'userTaskConfig'],
+  automated: ['activityType', 'activityId', 'activities'],
+  invokeAgent: ['activityType', 'activityId', 'activities', 'agentId', 'signalConfig'],
+  subWorkflow: [],
+  waitForSignal: ['signalConfig'],
+  waitForTimer: [],
+  waitForCondition: [],
+  parallelFork: [],
+  parallelJoin: [],
+  ifElse: [],
+  switch: [],
+}
+
+/** `node.data.config` keys each type actually executes. */
+const TYPE_CONFIG_KEYS: Record<ConvertibleStepType, readonly string[]> = {
+  userTask: [],
+  automated: [],
+  invokeAgent: [],
+  subWorkflow: ['subWorkflowId', 'version', 'inputMapping', 'outputMapping'],
+  waitForSignal: [],
+  waitForTimer: ['duration', 'until'],
+  waitForCondition: ['condition', 'timeout', 'onTimeout', 'pollIntervalMs'],
+  parallelFork: ['joinStepId'],
+  parallelJoin: ['forkStepId'],
+  ifElse: [],
+  switch: [],
+}
+
+/**
+ * Where a type keeps its "give up after" deadline. The two waiting types spell
+ * the same ISO-8601 duration differently, so the value travels between them
+ * instead of being quarantined. WAIT_FOR_TIMER's `duration` is deliberately not
+ * part of this: it is how long to wait ON PURPOSE, not when to give up.
+ */
+const DEADLINE_SLOTS: Partial<Record<ConvertibleStepType, { container: 'data' | 'config'; parent?: string; key: string }>> = {
+  waitForSignal: { container: 'data', parent: 'signalConfig', key: 'timeout' },
+  waitForCondition: { container: 'config', key: 'timeout' },
+}
+
+export interface ConvertibleStep {
+  type?: string | null
+  data?: Record<string, unknown> | null
+}
+
+export type StepTypeConversionResult =
+  | {
+      ok: true
+      type: ConvertibleStepType
+      data: Record<string, unknown>
+      /** Config keys moved to `unmappedConfig` by THIS conversion. */
+      quarantined: string[]
+    }
+  | { ok: false; code: 'sameType' | 'unsupportedSource' | 'unsupportedTarget' }
+
+export function isConvertibleStepType(type: string | null | undefined): type is ConvertibleStepType {
+  return typeof type === 'string' && (CONVERTIBLE_STEP_TYPES as string[]).includes(type)
+}
+
+/** Types a step of `sourceType` may be converted into (never itself). */
+export function listStepTypeConversionTargets(sourceType: string | null | undefined): ConvertibleStepType[] {
+  if (!isConvertibleStepType(sourceType)) return []
+  return CONVERTIBLE_STEP_TYPES.filter((candidate) => candidate !== sourceType)
+}
+
+/**
+ * Every type the inspector's step-type control lists, INCLUDING the step's
+ * current one. The control states what the step is today and changes it by
+ * picking something else, so an options list that omitted the current type
+ * could never render a value for it.
+ */
+export function listStepTypeConversionOptions(sourceType: string | null | undefined): ConvertibleStepType[] {
+  if (!isConvertibleStepType(sourceType)) return []
+  return [...CONVERTIBLE_STEP_TYPES]
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function hasKeys(value: Record<string, unknown>): boolean {
+  return Object.keys(value).length > 0
+}
+
+function readDeadline(type: ConvertibleStepType, data: Record<string, unknown>): unknown {
+  const slot = DEADLINE_SLOTS[type]
+  if (!slot) return undefined
+  const container = slot.container === 'config' ? data.config : slot.parent ? data[slot.parent] : data
+  if (!isRecord(container)) return undefined
+  const value = container[slot.key]
+  return typeof value === 'string' && value.length > 0 ? value : undefined
+}
+
+function isDeadlineKey(type: ConvertibleStepType, container: 'data' | 'config', parent: string | undefined, key: string): boolean {
+  const slot = DEADLINE_SLOTS[type]
+  if (!slot) return false
+  return slot.container === container && slot.parent === parent && slot.key === key
+}
+
+function writeDeadline(type: ConvertibleStepType, data: Record<string, unknown>, config: Record<string, unknown>, value: unknown): void {
+  const slot = DEADLINE_SLOTS[type]
+  if (!slot || value === undefined) return
+  if (slot.container === 'config') {
+    config[slot.key] = value
+    return
+  }
+  if (!slot.parent) {
+    data[slot.key] = value
+    return
+  }
+  const parent = isRecord(data[slot.parent]) ? { ...(data[slot.parent] as Record<string, unknown>) } : {}
+  parent[slot.key] = value
+  data[slot.parent] = parent
+}
+
+/**
+ * Convert one step to another type.
+ *
+ * Everything the target type executes is carried across, the shared deadline
+ * moves between the two waiting types, and every remaining key lands in
+ * `data.unmappedConfig` (merged with anything an earlier conversion already
+ * quarantined) so a later conversion back can pick it up.
+ */
+export function convertStepType(step: ConvertibleStep, targetType: string): StepTypeConversionResult {
+  const sourceType = step.type
+  if (!isConvertibleStepType(sourceType)) return { ok: false, code: 'unsupportedSource' }
+  if (!isConvertibleStepType(targetType)) return { ok: false, code: 'unsupportedTarget' }
+  if (sourceType === targetType) return { ok: false, code: 'sameType' }
+
+  const sourceData = isRecord(step.data) ? step.data : {}
+  const acceptedDataKeys = new Set<string>([...SHARED_DATA_KEYS, ...TYPE_DATA_KEYS[targetType]])
+  const acceptedConfigKeys = new Set<string>(TYPE_CONFIG_KEYS[targetType])
+
+  const nextData: Record<string, unknown> = {}
+  const nextConfig: Record<string, unknown> = {}
+  const quarantine: Record<string, unknown> = isRecord(sourceData.unmappedConfig)
+    ? { ...(sourceData.unmappedConfig as Record<string, unknown>) }
+    : {}
+  const quarantinedConfig: Record<string, unknown> = isRecord(quarantine.config)
+    ? { ...(quarantine.config as Record<string, unknown>) }
+    : {}
+  const quarantined: string[] = []
+
+  const deadline = readDeadline(sourceType, sourceData)
+
+  for (const [key, value] of Object.entries(sourceData)) {
+    if (key === 'unmappedConfig' || key === 'badge') continue
+    if (value === undefined) continue
+
+    if (key === 'config') {
+      if (!isRecord(value)) continue
+      for (const [configKey, configValue] of Object.entries(value)) {
+        if (configValue === undefined) continue
+        if (acceptedConfigKeys.has(configKey)) {
+          nextConfig[configKey] = configValue
+          continue
+        }
+        if (isDeadlineKey(sourceType, 'config', undefined, configKey) && DEADLINE_SLOTS[targetType]) continue
+        quarantinedConfig[configKey] = configValue
+        quarantined.push(`config.${configKey}`)
+      }
+      continue
+    }
+
+    if (acceptedDataKeys.has(key)) {
+      nextData[key] = value
+      continue
+    }
+
+    const deadlineSlot = DEADLINE_SLOTS[sourceType]
+    if (deadlineSlot && deadlineSlot.container === 'data' && deadlineSlot.parent === key && DEADLINE_SLOTS[targetType] && isRecord(value)) {
+      const remainder = { ...value }
+      delete remainder[deadlineSlot.key]
+      if (hasKeys(remainder)) {
+        quarantine[key] = remainder
+        quarantined.push(key)
+      }
+      continue
+    }
+
+    quarantine[key] = value
+    quarantined.push(key)
+  }
+
+  writeDeadline(targetType, nextData, nextConfig, deadline)
+
+  if (hasKeys(nextConfig)) nextData.config = nextConfig
+  if (hasKeys(quarantinedConfig)) quarantine.config = quarantinedConfig
+  if (hasKeys(quarantine)) nextData.unmappedConfig = quarantine
+
+  return { ok: true, type: targetType, data: nextData, quarantined }
+}
+
+/** True when a step carries quarantined config the Problems panel should flag. */
+export function readUnmappedStepConfig(data: unknown): Record<string, unknown> | null {
+  if (!isRecord(data)) return null
+  const unmapped = data.unmappedConfig
+  return isRecord(unmapped) && hasKeys(unmapped) ? unmapped : null
+}