Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/synthorg/engine/task_engine.py`:
- Around line 703-714: The handler is awaiting observer delivery inline in
_process_one() via _notify_observers(event), which stalls the single-writer hot
path; instead create or use a dedicated background dispatcher/queue (e.g., an
_observer_dispatcher with an enqueue() method or an asyncio task runner) and
push the built event to it without awaiting delivery here — leave
publish_snapshot awaited when _config.publish_snapshots is true but replace
direct calls to await self._notify_observers(event) (and the similar occurrence
around the other build_state_changed_event usage) with non-blocking
enqueue/dispatch to the background dispatcher so observer delivery happens
asynchronously and best-effort.

In `@src/synthorg/engine/workflow/execution_activation_helpers.py`:
- Around line 256-284: The code currently coerces unknown config values into
defaults (using _TASK_TYPE_MAP/_PRIORITY_MAP/_COMPLEXITY_MAP) which masks
invalid workflow definitions; change this to validate and reject invalid values
instead: for each of raw_type/raw_priority/raw_complexity, check membership in
the respective map and if missing call logger.error(WORKFLOW_EXEC_TASK_CREATED,
execution_id=execution_id, node_id=nid, note=...) and raise an exception (e.g.,
ValueError or the service's workflow validation exception) instead of falling
back to TaskType.DEVELOPMENT/Priority.MEDIUM/Complexity.MEDIUM so
activation/validation stops and the caller can surface the error. Ensure
references to _TASK_TYPE_MAP, _PRIORITY_MAP, _COMPLEXITY_MAP, TaskType,
Priority, Complexity, WORKFLOW_EXEC_TASK_CREATED, execution_id, nid and config
are used to locate the exact checks to change.
- Around line 185-196: Replace the parenthesized multi-except with the
repo-standard PEP 758 form: in the try/except that calls
evaluate_condition(expr, ctx) (the block that currently catches (ValueError,
TypeError, KeyError) as exc), change the except clause to use comma-separated
exception types (except ValueError, TypeError, KeyError as exc:) and keep the
existing logging (logger.exception(...)) and raise
WorkflowConditionEvalError(msg) from exc unchanged; this touches the
evaluate_condition call and the WorkflowConditionEvalError raise in the same
block.

In `@src/synthorg/engine/workflow/execution_observer.py`:
- Around line 1-58: This module lacks the required module-level logger; add
"from synthorg.observability import get_logger" and create logger =
get_logger(__name__) at top-level, then use that logger in
WorkflowExecutionObserver (e.g., log entry/exit or important info in __init__
and async __call__ when delegating to
WorkflowExecutionService.handle_task_state_changed) to satisfy the guideline
that every business-logic module must set up a logger for observability.

In `@src/synthorg/engine/workflow/execution_service.py`:
- Around line 695-711: The _find_execution_by_task function currently scans all
RUNNING executions via _execution_repo.list_by_status and nested
node_executions, causing O(running×nodes) work; replace this with a
repository-level lookup keyed by task_id (e.g., add and call a new method like
_execution_repo.get_by_task_id or _execution_repo.find_execution_for_task) so
the TaskEngine observer uses a constant-time indexed lookup; update the
WorkflowExecutionRepository interface/implementation to maintain the task_id ->
execution_id index (or query) and switch _find_execution_by_task to call that
new repository method instead of iterating.
- Around line 540-544: The WORKFLOW_EXEC_FAILED log is emitted after the state
is already persisted and should be an informational state transition, not a
warning; update the two logging calls that currently use logger.warning (the
call that passes WORKFLOW_EXEC_FAILED with execution_id and error around the
block using execution_id, and the analogous call around lines 612-616) to use
logger.info instead, keeping the same message key and structured fields
(execution_id, error) so the transition remains logged at INFO level.

In `@tests/unit/engine/workflow/test_execution_lifecycle.py`:
- Around line 457-493: Parametrize the two tests that only exercise
TaskStatus.FAILED to also assert behavior for TaskStatus.CANCELLED by converting
them to use `@pytest.mark.parametrize` over statuses [TaskStatus.FAILED,
TaskStatus.CANCELLED]; call service.handle_task_state_changed with
_make_task_event(task_id, status) and assert the same terminal outcomes
(stored.status is WorkflowExecutionStatus.FAILED in
test_task_failed_transitions_to_failed and nmap["task-a"].status is
WorkflowNodeExecutionStatus.TASK_FAILED in
test_task_failed_updates_node_to_task_failed) so the cancel branch is covered;
keep references to _activate_simple/_activate_parallel, _get_task_ids,
_make_task_event, WorkflowExecutionStatus.FAILED, and
WorkflowNodeExecutionStatus.TASK_FAILED when locating changes.

In `@tests/unit/engine/workflow/test_execution_models.py`:
- Around line 278-331: Replace the four nearly-identical tests in
TestTaskLinkedStatusOnNonTaskNodes with a single parametrized test using
pytest.mark.parametrize: create one test (e.g.,
test_task_linked_status_on_non_task_node_rejected) that takes node_type and
status parameters and asserts WorkflowNodeExecution raises ValidationError for
those combinations; reference the existing symbols WorkflowNodeExecution,
WorkflowNodeType, WorkflowNodeExecutionStatus, and ValidationError and supply
the tuples [(WorkflowNodeType.START,
WorkflowNodeExecutionStatus.TASK_COMPLETED), (WorkflowNodeType.START,
WorkflowNodeExecutionStatus.TASK_FAILED), (WorkflowNodeType.END,
WorkflowNodeExecutionStatus.TASK_COMPLETED), (WorkflowNodeType.CONDITIONAL,
WorkflowNodeExecutionStatus.TASK_CREATED)] so the behavior stays identical but
avoids duplication.

In `@web/src/hooks/useWorkflowsData.ts`:
- Around line 33-34: Remove the dead pollingRef by deleting the declaration
"const pollingRef = useRef(polling)" and the subsequent assignment
"pollingRef.current = polling" in useWorkflowsData; also remove any now-unused
import of useRef if it becomes unused after this change so there are no
lingering unused variables or imports.

In `@web/src/pages/workflow-editor/condition-expression-types.ts`:
- Around line 59-68: The serializer currently maps expr.conditions and joins
parts without handling an empty ConditionGroup, causing an empty string output;
update the code that builds parts (the block calling serializeCondition(c) and
joining with expr.logicalOperator) to guard against empty groups: when expr.kind
=== 'group' and expr.conditions.length === 0 either return a safe default (e.g.,
an explicit empty-group token or empty string) or throw a validation error so
downstream consumers don't receive malformed output—apply this check in the
function that handles ConditionGroup/serializeCondition so empty expr.conditions
are handled before mapping and joining.
- Around line 102-119: The loop that splits `str` by `token` uses a `depth`
counter but doesn't guard against unbalanced parentheses; modify the logic in
the function that contains this loop to detect when `depth` goes negative during
iteration (e.g., when encountering a ')' with `depth === 0`) and immediately
return null (or otherwise signal an error), and after the loop check that `depth
=== 0` before returning `parts`—if not, return null; use the existing
identifiers (`str`, `token`, `depth`, `i`, `current`, `parts`) to implement
these checks so callers can handle malformed input.

In `@web/src/pages/workflow-editor/ConditionExpressionBuilder.tsx`:
- Around line 211-217: The builder only syncs builder→parent; add logic to
detect external changes to the incoming value and reset builder state
accordingly: create a lastSyncedRef to track the last value we pushed, add an
effect that runs on value changes which computes serialized =
serializeCondition(buildExpression(comparisons, logicalOperator)) and returns
early if value === serialized or value === lastSyncedRef.current, otherwise
parse the new value with parseForBuilder and, if parse succeeds call
setEntries(toEntries(...)), setLogicalOperator(...), setMode('builder'), else
setFreeText(value) and setMode('advanced'); finally update lastSyncedRef.current
= value. Use these symbols to locate code: buildExpression, serializeCondition,
parseForBuilder, setEntries, setLogicalOperator, setMode, setFreeText, and
lastSyncedRef.
- Around line 286-299: The SegmentedControl placed between rows currently
mutates the shared logicalOperator state (logicalOperator, setLogicalOperator)
which can confuse users into thinking each row has its own operator; update the
UI to clarify this by either (a) showing the SegmentedControl only once above
the condition rows with a helper label/tooltip that states "Applies to all rows"
or (b) keep the per-row control but add a persistent tooltip/info icon (adjacent
to SegmentedControl) that explains "This operator is global across all
conditions in this builder" and make the per-row controls visually muted (or
disabled) to indicate they are not independent; adjust the JSX in
ConditionExpressionBuilder around the SegmentedControl usage and ensure the
tooltip text references the flat-builder behavior so users understand the global
scope of logicalOperator.
- Around line 252-267: The handler handleModeChange currently switches to
'builder' even if parseForBuilder(freeText) returns null, leaving stale entries;
change it so when newMode === 'builder' you call parseForBuilder(freeText) and
if it returns null you do NOT call setMode('builder') but instead set a
validation flag (e.g., setParseError / setValidationError) to surface the
failure to the user; only when parseForBuilder returns a valid flat object
should you call setEntries(toEntries(flat.comparisons)),
setLogicalOperator(flat.logicalOperator) and setMode('builder'); keep the
existing advanced->freeText path (buildExpression/serializeCondition) as-is.
- Around line 196-207: Compute parseForBuilder(value) once during initialization
and reuse the result for all initial state values: call parseForBuilder(value)
once (e.g., const parsed = parseForBuilder(value)) and then use
parsed?.comparisons (fallback to [createComparison()]) for entries via
toEntries, parsed?.logicalOperator ?? 'AND' for logicalOperator, and parsed for
getInitialMode/freeText; update the entries/setEntries,
logicalOperator/setLogicalOperator, and freeText initializers to reference that
single parsed value and remove the extra parseForBuilder calls.
- Around line 102-157: Replace the native <select> for the operator in
ConditionExpressionBuilder with the project's SelectField component: use
options={OPERATORS} (OPERATORS is already in {value,label} shape), bind value to
comparison.operator and call onUpdate(index, { ...comparison, operator: newValue
}) from SelectField's onChange, preserve the existing className/aria-label and
width (w-24) so layout doesn't shift, and remove the inner <option> mapping and
related fragments.

In `@web/src/pages/workflow-editor/WorkflowSelector.tsx`:
- Around line 20-46: The WorkflowSelector component is using raw <select>
elements instead of the shared UI primitives; refactor the JSX in
WorkflowSelector to use the dashboard's shared form/select components from
web/src/components/ui/ (e.g., the Select, SelectTrigger, SelectValue,
SelectContent, SelectItem primitives) while preserving behavior tied to
props/current state (currentId, onChange, workflows) and the loading state
branch—map workflows to SelectItem using w.id and w.name and ensure the onChange
handler calls onChange(value) only when a non-empty value is chosen.

In `@web/src/pages/workflow-editor/WorkflowYamlEditor.tsx`:
- Around line 63-71: When replacing the entire graph in
useWorkflowEditorStore.setState (the block that sets nodes to mappedNodes, edges
to result.edges, dirty/yamlPreview/undoStack/redoStack), also clear the stale
selection by resetting selectedNodeId (and optionally selectedEdgeId) to
null/undefined so the inspector won't point at a removed/renamed node; update
the setState call to include selectedNodeId: null (and selectedEdgeId: null if
present).
- Around line 21-31: yamlText is only set once from initialYaml so the editor
doesn't update when initialYaml changes; add a useEffect that watches
initialYaml and calls setYamlText(initialYaml) (and optionally reset
setParseErrors([]), setParseWarnings([]), and setApplied(false)) so the local
editor state resyncs whenever the parent-provided initialYaml changes; reference
the existing state hooks yamlText, setYamlText, parseErrors, parseWarnings,
applied, and appliedTimerRef and implement the effect using initialYaml as the
dependency.

In `@web/src/pages/workflow-editor/yaml-to-nodes.ts`:
- Around line 146-169: The YAML import currently collapses branch and
conditional semantics because inferEdgeType() is always resulting in
'sequential' and branch edges are hard-coded to type 'sequential'; update the
import to preserve/derive the correct edge type by (1) fixing inferEdgeType() to
inspect the step metadata (e.g., step.condition, step.type, or any saved
edgeType) and return 'conditional' or 'sequential' accordingly, (2) when
building edges from step.depends_on push edges with type set to the returned
value (not forced to 'sequential') and keep data.edgeType in sync, and (3) when
building edges from step.branches emit a dedicated parallel edge type (e.g.,
'parallel' or 'parallel_branch') and set data.edgeType to 'parallel_branch' (and
apply the same change for the other similar block around lines 238-244) so
round-tripping preserves true/false and parallel-split semantics; refer to
inferEdgeType(), the edges array construction for step.depends_on, and the
branch-edge construction for step.branches.
- Around line 103-105: The code currently sets firstStepId and emits edges while
iterating YAML order, which can create edges to skipped/invalid steps; instead,
first pass: collect and validate all steps into stepIds and a map of
validStepIds (use existing firstStepId only after validation), create nodes for
them; second pass: iterate steps' depends_on and branches to emit edges only
when both source and target exist in the validated map, and finally connect
"start-1" to the computed root steps (those without incoming validated edges)
rather than using the original file order; update logic around firstStepId,
stepIds, and edge emission to follow this two-pass approach and reference
depends_on, branches, and "start-1" when implementing checks.

In `@web/src/pages/WorkflowEditorPage.tsx`:
- Around line 336-340: The WorkflowYamlEditor initializes its internal yamlText
from the initialYaml prop but doesn't update when initialYaml (e.g.,
yamlPreview) changes while the editor is mounted, causing stale content on
undo/redo; add a useEffect in WorkflowYamlEditor that watches initialYaml and
calls setYamlText(initialYaml) (useEffect(() => { setYamlText(initialYaml) },
[initialYaml])) to auto-sync, or alternatively document in the component
props/readme that yamlText intentionally preserves unsaved edits and provide a
Revert control for manual reset.

In `@web/src/pages/workflows/WorkflowCard.tsx`:
- Around line 48-131: The card shell in WorkflowCard is hand-rolled (the outer
div with rounded-lg border bg-card p-card etc.)—replace that with the shared
SectionCard component to avoid duplicating card-with-header layout; wrap the
existing inner content (title, labels, description, stats, version/updated) as
SectionCard children and move the header elements (workflow.name +
workflow.workflow_type badge) into SectionCard's header slot or props if it has
one, retain the Link to editorUrl and keep the menu toggle logic (menuRef,
menuOpen, setMenuOpen, onDuplicate, setConfirmDelete) but adjust
positioning/classes so the menu button remains absolutely positioned (e.g.,
ensure SectionCard is relatively positioned or pass a className to SectionCard).

In `@web/src/pages/workflows/WorkflowCreateDrawer.tsx`:
- Around line 61-63: After a successful create (where you call
useToastStore.getState().add and setForm(INITIAL_FORM)), also clear any
validation state before closing the drawer: reset the errors and submitError
state via their setters (e.g., call setErrors(...) and setSubmitError(...) — or
the equivalent state updater used in this component) immediately before
setForm(INITIAL_FORM) or at least before calling onClose(), then call onClose()
so stale validation messages won't appear if the drawer is reopened.

In `@web/src/pages/workflows/WorkflowFilters.tsx`:
- Around line 19-35: The JSX in WorkflowFilters.tsx uses raw <input> and
<select> elements for searchQuery and workflowTypeFilter (handlers
setSearchQuery, setWorkflowTypeFilter) which duplicates styling/behavior;
replace them with the shared UI components from web/src/components/ui (e.g., the
project's Input/TextInput and Select components) and wire their value and
onChange props to searchQuery/setSearchQuery and
workflowTypeFilter/setWorkflowTypeFilter (mapping empty string to null as
before) so styling, accessibility and behavior are centralized.

In `@web/src/stores/workflows.ts`:
- Around line 74-79: The deleteWorkflow handler is unconditionally decrementing
totalWorkflows even when no workflow matched the id; update deleteWorkflow to
call deleteWorkflowApi(id) as before but compute the filtered list and compare
lengths (or check whether any item was removed) before updating state: set
workflows to the filtered array and only adjust totalWorkflows when the new
length is less than the previous length (or set totalWorkflows to Math.max(0,
newLength)) so counts cannot desync or go negative; reference the deleteWorkflow
function, deleteWorkflowApi call, the workflows array and totalWorkflows field
when making this change.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/synthorg/engine/workflow/execution_activation_helpers.py`:
- Around line 175-184: The current code treats a missing or blank
node.config["condition_expression"] as false; instead, detect if
condition_expression is absent or empty (e.g., expr == "" or
node.config.get("condition_expression") is None/blank) before calling
evaluate_condition(), log using WORKFLOW_EXEC_CONDITION_EVAL_FAILED with
execution_id, node_id (nid) and expression (expr), and raise
WorkflowConditionEvalError so activation is rejected; update the block around
expr/evaluate_condition() to perform this validation and short-circuit by
logging and raising the WorkflowConditionEvalError rather than logging a warning
and defaulting to false.

In `@src/synthorg/engine/workflow/execution_service.py`:
- Around line 493-545: The lifecycle transition methods (e.g., fail_execution
and the similar complete/cancel handlers) currently read an execution via
_load_running, set status and version = execution.version + 1, then call
_execution_repo.save, which will raise VersionConflictError on races; refactor
these to use a conflict-aware retry pattern (extract or add a helper like
_save_with_conflict_retry) that on VersionConflictError reloads the execution
from storage, checks if its status is already a terminal state
(WorkflowExecutionStatus.FAILED/COMPLETED/CANCELLED) and if so returns that
reloaded execution as a benign no-op, otherwise applies the
status/update/version increment against the fresh model and retries the save
until success or a limited retry count; replace direct calls to
_execution_repo.save in fail_execution (and the same logic around
complete_execution and cancel_execution referenced) with this helper and ensure
the logger uses the final persisted entity.
- Around line 744-746: Before raising the ValueError when "found" is false, emit
a log at WARNING or ERROR with structured context including execution_id
(execution.id) and task_id; e.g., call the module/class logger (use the existing
logger object or self.logger used elsewhere in execution_service.py) to log a
message like "task/execution correlation failure" with execution_id and task_id
fields, then raise the ValueError as currently written to preserve behavior.

In `@tests/unit/engine/workflow/test_execution_lifecycle.py`:
- Around line 93-105: list_by_definition() and list_by_status() currently return
live references from self._store; change them to return deep copies so the fake
repo mirrors get() behavior and prevents in-place mutation from leaking into
tests. Use copy.deepcopy to return copies of the stored WorkflowExecution
objects (e.g., return tuple(copy.deepcopy(e) for e in self._store.values() if
...)) and add the necessary import for the copy module; update both
list_by_definition and list_by_status accordingly.

In `@web/src/pages/workflow-editor/condition-expression-types.ts`:
- Around line 174-180: The NOT parsing currently flattens an inner group by
using inner.conditions, dropping the group's operator (so NOT (a==1 OR b==2)
becomes NOT a==1 AND b==2 after serialization); change the logic in the NOT
handling inside parseConditionString so that if
parseConditionString(notMatch[1]) returns a group you do not extract its
.conditions but instead treat the whole group as a single child (i.e., children
= [inner] for inner.kind === 'group', otherwise children = [inner]) and then
call createGroup('NOT', children) so the inner operator is preserved when
serialized.

In `@web/src/pages/workflow-editor/ConditionExpressionBuilder.tsx`:
- Around line 58-64: parseForBuilder currently calls flattenExpression() which
returns null for nested ConditionGroup nodes produced by buildExpression(),
causing any expression created with "Add group" to be unreadable by the builder;
fix parseForBuilder (which calls parseConditionString) to recursively handle
ConditionGroup nodes instead of flattening them: traverse the parsed AST and
convert nested ConditionGroup nodes into the builder's representation (or extend
flattenExpression to support nested groups), preserving nested logical operators
and comparisons so parseForBuilder returns a non-null structure for grouped
expressions; reference parseForBuilder, parseConditionString, flattenExpression,
buildExpression and ConditionGroup when implementing the recursive conversion.
- Around line 217-241: The guard that prevents re-parsing only compares value
against a serialization built from entries.map(e => e.comparison) and
logicalOperator, missing per-entry negate and subGroups so builder-originated
updates that toggle NOT or add subgroups get treated as external; update the
guard to compute currentSerialized using the full entry objects (including
negate and subGroups) instead of only e.comparison — i.e., change
currentComparisons to use the entire entry (or adjust
buildExpression/serializeCondition to accept entries), then call
serializeCondition(buildExpression(currentEntries, logicalOperator)) so
lastSyncedRef correctly matches builder-originated serializations and avoid
needless reparsing; keep the rest of the effect (parseForBuilder, setEntries,
setLogicalOperator, setMode, setFreeText) unchanged.
- Around line 351-362: handleModeChange currently drops or leaks builder-only
state: when switching builder→advanced you serialize without applying the
group's negate and subgroup structure, and advanced→builder only restores
comparisons and logicalOperator so previous negate/subGroups can bleed through.
Fix by, in the 'advanced' branch, building the full expression via
buildExpression(comparisons, logicalOperator, subGroups) and ensure you apply
any group-level negate before calling serializeCondition and setFreeText (e.g.,
wrap or mark the expr as negated); in the 'builder' branch, after
parseForBuilder(freeText) succeeds, restore all builder state returned by the
parser — call setEntries(toEntries(flat.comparisons)),
setLogicalOperator(flat.logicalOperator), setNegate(flat.negate) and
setSubGroups(flat.subGroups) (or clear subGroups if parser returns none) so
negate and subgroup state are correctly synced; keep the existing early-return
if parse fails.

In `@web/src/pages/workflow-editor/WorkflowYamlEditor.tsx`:
- Around line 57-62: The handler currently updates the editor state whenever
result.errors is empty, which lets warn-only parses (e.g., unsupported step
types or missing ids) drop nodes silently; modify parseYamlToNodesEdges to
return a concrete indicator of dropped/unsupported nodes (e.g.,
result.droppedNodes or result.unsupportedSteps array) and then change the
early-return condition to: if (result.errors.length > 0 || result.droppedNodes)
return; keep setting parse errors/warnings with setParseErrors/setParseWarnings
but only call setNodes/setEdges (or otherwise commit the parse) when there are
no errors and no droppedNodes/unsupportedSteps. Use the function and state names
parseYamlToNodesEdges, setParseErrors, setParseWarnings, setNodes, setEdges to
locate the code to change.

In `@web/src/pages/workflow-editor/yaml-to-nodes.ts`:
- Around line 81-89: The import is guessing conditional edges by YAML order in
inferDependsOnEdgeType, which breaks round-trip because workflow-to-yaml only
emits plain depends_on ids; change the YAML serialization (workflow-to-yaml.ts)
to emit depends_on entries with explicit edge type metadata (e.g., object { id,
edge: "conditional_true" | "conditional_false" | "sequential" }) when source
step is conditional, and update the parser (yaml-to-nodes.ts) and
inferDependsOnEdgeType to prefer that explicit edge field instead of deriving
from branch index; keep a fallback to the old string form for backward
compatibility (preserve current behavior if depends_on is a string) and update
both places mentioned (the inferDependsOnEdgeType function and the serializer
around the block referenced at 103-129 and the other spots around 213-223) so
conditional_true/conditional_false are preserved across export/import.
- Around line 149-161: The bug is that seenIds is populated before validating
step type so unknown-type steps are treated as "seen" and later dependency
resolution calls stepMap.get(depId)! which can be undefined (causing
inferDependsOnEdgeType to throw); fix by moving seenIds.add(stepId) (and adding
to stepMap) only after validating stepType (i.e., after checking VALID_TYPES and
before continuing), and in dependency-resolution passes (the blocks around lines
referenced 205-215 and 240-244) guard uses of stepMap.get(depId)! by first
checking stepMap.has(depId) (or skipping/issuing a warning when the dependency
is not in stepMap) so inferDependsOnEdgeType only receives validated steps.

In `@web/src/pages/WorkflowEditorPage.tsx`:
- Around line 304-362: The node drawer (WorkflowNodeDrawer) is rendered even in
YAML mode causing a stale inspector to remain; update the rendering logic so
WorkflowNodeDrawer only mounts when editorMode === 'visual' (and when a node is
selected) and ensure any selection state is cleared when switching out of visual
mode (e.g., call setSelectedNode(null) or invoke the existing close handler
inside the mode switch). Locate WorkflowNodeDrawer, editorMode, and the
selection state setter (setSelectedNode or equivalent) and wrap the drawer
render in a conditional check for editorMode === 'visual', plus clear selection
on mode change.

In `@web/src/pages/workflows/WorkflowCard.tsx`:
- Around line 69-72: The DropdownMenu.Content element's className currently
includes the Tailwind utility "shadow-lg" which bypasses design-system shadow
tokens; update the className on DropdownMenu.Content to remove "shadow-lg" and
add the design token variable (e.g. var(--so-shadow-card-hover) or the
appropriate shadow token) so the component uses the tokenized elevation, keeping
existing classes like "z-50 w-36 rounded-lg border border-border bg-card py-1"
intact; search for the DropdownMenu.Content usage in WorkflowCard.tsx to make
this change.
- Around line 1-2: The file WorkflowCard.tsx imports DropdownMenu from the
umbrella 'radix-ui' package; change that import to use the specific package by
replacing the current import of DropdownMenu with an import from
'@radix-ui/react-dropdown-menu' so it matches WorkflowTableView.tsx and follows
Radix recommendations (update the import that references DropdownMenu in
WorkflowCard.tsx).

In `@web/src/pages/workflows/WorkflowFilters.tsx`:
- Around line 7-17: Extract the duplicated WORKFLOW_TYPES constant into a shared
module (e.g., create and export WORKFLOW_TYPES and an associated WorkflowType
type from a new file like `@/utils/constants.ts` or `@/api/types.ts`) and update
both WorkflowFilters.tsx and WorkflowCreateDrawer.tsx to import WORKFLOW_TYPES;
keep WORKFLOW_TYPE_OPTIONS and formatLabel usage in WorkflowFilters.tsx
unchanged but build it from the imported WORKFLOW_TYPES, and ensure any type
annotations referencing the literal array use the exported WorkflowType type.

In `@web/src/pages/workflows/WorkflowTableView.tsx`:
- Around line 58-64: The table row in WorkflowTableView.tsx currently uses
role="link" on the <tr> but isn’t keyboard-focusable or activatable; make the
row keyboard-accessible by adding tabIndex={0} and an onKeyDown handler (e.g.,
handleRowKeyDown) that calls navigate(editorUrl) when Enter or Space is pressed,
while preserving the existing onClick and aria-label; ensure the handler ignores
key events originating from interactive child elements so clicks on overflow
menu/buttons still behave normally.
- Around line 87-90: The DropdownMenu.Content currently uses the hardcoded
Tailwind utility "shadow-md"; update the dropdown panel to use the shared shadow
token instead by replacing that utility in the className of DropdownMenu.Content
with the shadow token (e.g. use the CSS variable var(--so-shadow-card-hover) as
the shadow), ensuring you keep the other tokenized classes like border-border
and the existing layout classes intact so the final className references the
shared shadow token rather than "shadow-md".

In `@web/src/stores/workflows.ts`:
- Around line 44-59: The fetchWorkflows implementation currently hardcodes
listWorkflows({ limit: 200 }); update fetchWorkflows to accept optional paging
parameters (e.g., limit and cursor/pageToken) or a config object, pass those
through to listWorkflows instead of the fixed 200, and expose a new method
(e.g., fetchWorkflowsPage or fetchWorkflows({ limit, cursor })) to support
cursor-based pagination; update any callers of fetchWorkflows to provide desired
limits or iterate using the cursor returned in result
(result.total/result.nextCursor) so large deployments can request pages instead
of relying on a single fixed limit.

---

Duplicate comments:
In `@src/synthorg/engine/task_engine.py`:
- Around line 703-714: The code currently awaits self._notify_observers(event)
inside _process_one(), blocking the single-writer path; change this to enqueue
or schedule observer delivery on a TaskEngine-owned background dispatcher so
observer handlers run asynchronously and don't stall later mutations. Implement
or reuse a lifecycle-owned queue/worker (e.g., create a self._observer_queue and
a background coroutine worker or a helper method like
_enqueue_observer_event(event) that uses asyncio.create_task or puts the event
on the queue) and have the worker call _notify_observers(event); ensure the
dispatcher is started when TaskEngine initializes and drained/stopped cleanly on
shutdown so observer delivery is eventual and not awaited inline in
_process_one().

In `@src/synthorg/engine/workflow/execution_activation_helpers.py`:
- Around line 187-196: Replace the parenthesized multi-except "except
(ValueError, TypeError, KeyError) as exc:" with the Python 3.14 multi-except
form (use the exception union operator) so it becomes "except ValueError |
TypeError | KeyError as exc:"; keep the body unchanged (the logger.exception
call that uses WORKFLOW_EXEC_CONDITION_EVAL_FAILED and the raise of
WorkflowConditionEvalError that references execution_id, nid, expr should remain
intact).

In `@src/synthorg/engine/workflow/execution_observer.py`:
- Around line 9-25: The module is missing the required module logger; add the
repo-standard logger by importing get_logger from synthorg.observability and
creating logger = get_logger(__name__) near the top of the file so
WorkflowExecutionObserver (and any top-level delegation/tracing) can emit DEBUG
traces using logger.debug(...) per the repo contract.

In `@web/src/pages/workflows/WorkflowCard.tsx`:
- Around line 25-50: Replace the custom outer div shell in WorkflowCard (the
rounded-lg border block wrapping the Link) with the shared SectionCard
component: move the workflow name, workflow_type badge
(formatLabel(workflow.workflow_type)) and optional description into
SectionCard's header/title area (use SectionCard props or header slot as
appropriate), keep the Link around the clickable header/body content, and place
the StatPill cluster (Nodes/Edges) and the footer row (version and Updated
formatRelativeTime(workflow.updated_at)) into the SectionCard body/footer;
remove the handcrafted border/spacing classes and rely on SectionCard for chrome
so spacing and header styling are consistent across the app.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@web/src/pages/workflow-editor/condition-expression-types.ts`:
- Around line 209-223: flattenExpression currently treats a unary NOT as a flat
logicalOperator which causes double-negation in ConditionExpressionBuilder;
change flattenExpression (the function named flattenExpression in this file) to
detect expr.logicalOperator === 'NOT' and do not flatten such expressions —
return null for NOT groups (or alternatively extend the return shape to include
a separate negate boolean and set negate=true instead of using
logicalOperator='NOT'); ensure callers (e.g., ConditionExpressionBuilder)
continue to rely on its separate negation tracking when NOT groups are
encountered.

In `@web/src/pages/workflow-editor/ConditionExpressionBuilder.tsx`:
- Around line 396-465: The JSX for entries.map and subGroups.map is too large
and duplicates layout/behavior; extract a ConditionRow component to render each
entry (use ComparisonRow, SegmentedControl, pass props like comparison, index,
baseId, canRemove, onUpdate: handleUpdateRow, onRemove: handleRemoveRow) and
extract a ConditionGroup component to render each group (use group.operator,
group.key, map group.entries to ConditionRow via
handleGroupUpdateRow/handleGroupRemoveRow, call handleGroupOperatorChange and
handleRemoveGroup), and replace the raw <button> in the subgroup block with the
shared Button component and the existing handleGroupAddRow handler so all wiring
is centralized and maps contain only <ConditionRow /> or <ConditionGroup />
calls.

In `@web/src/pages/workflows/WorkflowTableView.tsx`:
- Line 92: The element in WorkflowTableView.tsx currently uses a hardcoded
min-w-[140px] in its className; replace that with a design token or standard
Tailwind spacing class to avoid pixel hardcoding—for example use the project's
density-aware token (e.g., min-w-card or a provided token for card/min column
width) or a standard Tailwind spacing equivalent (e.g., min-w-36 / 9rem) so
sizing follows the design system; update the className string where
min-w-[140px] appears.

---

Duplicate comments:
In `@web/src/pages/workflow-editor/ConditionExpressionBuilder.tsx`:
- Around line 58-64: parseForBuilder currently returns null when
flattenExpression encounters nested groups, breaking round-trip for conditions
created by handleAddGroup; update parseForBuilder/flattenExpression so they
recursively traverse the AST returned by parseConditionString and either (A)
flatten nested GroupExpression nodes into the comparisons array in the shape the
builder expects or (B) return a structured representation the builder can
consume (preserving group boundaries) instead of null. Locate parseForBuilder,
flattenExpression and handleAddGroup and implement a recursive merge or
conversion of nested groups into the builder's expected format (ensuring
logicalOperator for the outer group is preserved) so grouped conditions reopen
in Structured mode rather than Advanced.

In `@web/src/pages/workflow-editor/yaml-to-nodes.ts`:
- Around line 205-220: The current logic derives conditional branch labels using
conditionalBranchCounters, which breaks semantics when YAML order changes;
update the depends_on handling so that each dependency entry can be either a
string or an object with explicit edge metadata (e.g. { id: "stepA", branch:
"true" } or similar), and prefer that explicit branch label to determine the
edge type (pass the explicit label into inferDependsOnEdgeType or a new helper)
when present; only fall back to using conditionalBranchCounters when no explicit
branch metadata exists, and only increment conditionalBranchCounters in that
fallback path for sourceStep.type === 'conditional' so existing workflows remain
compatible.

In `@web/src/pages/workflows/WorkflowCard.tsx`:
- Around line 25-98: The card UI in WorkflowCard.tsx is implemented manually;
replace the outer <div className="relative rounded-lg ..."> wrapper with the
shared SectionCard component and move the header/title, meta (version/updated),
body (description, StatPill row), and action menu into the appropriate
SectionCard slots/props (e.g., title slot for the workflow.name and
workflow.workflow_type badge, actions slot for the DropdownMenu Trigger/Portal,
body for description and StatPill), preserving existing behavior of Link to
editorUrl, the Edit/Duplicate/Delete handlers (onDuplicate, setConfirmDelete,
navigate), and CSS classes where needed so styling and interaction remain
identical while using SectionCard instead of a bespoke shell.
- Around line 1-2: Replace the ambiguous import "import { DropdownMenu } from
'radix-ui'" in WorkflowCard.tsx with the specific package "import { DropdownMenu
} from '@radix-ui/react-dropdown-menu' so it matches the pattern used in other
workflow pages (e.g., WorkflowTableView.tsx); update any related named imports
if necessary to align with `@radix-ui/react-dropdown-menu` exports and run the
same search used in the review to verify no other files import from 'radix-ui'
and that package.json has the correct dependency entry.

In `@web/src/pages/workflows/WorkflowTableView.tsx`:
- Around line 58-64: The row-level onKeyDown handler in WorkflowTableView.tsx
calls navigate(editorUrl) for Enter/Space even when the event comes from
interactive children; update the onKeyDown for the <tr> to ignore events
originating from nested interactive elements by checking the event target (e.g.,
using e.currentTarget vs e.target or DOM traversal like target.closest) and only
call navigate(editorUrl) when the key event originates from the row itself (not
from descendants such as button, a, input, select, textarea, or elements with
role="button"/"menuitem"); keep the Enter/Space check and preventDefault
behavior but bail out early if an interactive ancestor is found so child
controls retain their expected behavior.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@web/src/pages/workflow-editor/condition-expression-types.ts`:
- Around line 45-76: serializeCondition currently emits AND/OR/NOT groups which
the runtime (see condition_eval.py evaluator for boolean literal/truthy lookups
and only ==/!= comparisons) cannot parse; update serializeCondition to only
produce single comparisons and to fail-fast when given compound/group
expressions: detect when expr.kind === 'group' or expr.logicalOperator is set
(and when expr.conditions.length > 1 or logicalOperator !== 'NONE'), and either
throw a clear error or return an explicit validation failure so the
caller/editor cannot save/send unsupported compound conditions; reference the
serializeCondition function and the ConditionExpression shape to locate where to
add this validation/guard.

In `@web/src/pages/workflow-editor/ConditionExpressionBuilder.tsx`:
- Around line 61-76: buildExpression currently emits all ConditionComparison
items before all SubGroupEntry items which reorders top-level items; change the
function to preserve original top-level order by accepting and iterating a
single ordered list of root items (e.g. parameter typed as
Array<ConditionComparison | SubGroupEntry> or a discriminated union) rather than
separate comparisons and subGroups, and when encountering a SubGroupEntry
produce either its single comparison or createGroup(group.operator,
group.entries.map(e=>e.comparison)); keep the existing use of createGroup and
LogicalOperator but build items in the passed order so (a AND b) OR c stays in
that order and round-trip parsing/serialization is stable.

In `@web/src/pages/workflow-editor/yaml-to-nodes.ts`:
- Around line 235-245: The edges creation in yaml-to-nodes.ts (the edges.push
block that builds id `edge-${depId}-${stepId}` and the similar block at lines
~259-265) can emit duplicate edges for depends_on/branches/repeated items; fix
by introducing a dedup set (e.g., emittedEdgeIds or emittedEdgeTuples) and check
before pushing: compute a unique key using source, target and edgeType (or
sourceHandle/branch) and skip pushing if the key already exists, otherwise add
the key to the set and then call edges.push; update both the edges.push sites to
use this guard so duplicate relations are not emitted.
- Around line 149-171: Normalize and validate step ids early in the Pass 1 loop
in yaml-to-nodes.ts: trim the raw step.id, treat an empty or whitespace-only
trimmed id as missing (so auto-generate using autoIdCounter), reject reserved
ids like "start-1" and "end-1" by pushing to errors, and check for duplicates on
the normalized id before adding to seenIds/stepMap; apply the same
normalization/validation logic in the other ID handling blocks (the similar code
at ranges 177-183 and 273-282) so reserved and whitespace-only ids are caught
consistently and synthetic nodes won't collide with user ids.
- Around line 149-171: The code currently casts each entry in steps to YamlStep
and auto-creates a task node for non-object YAML values; update the loop in
yaml-to-nodes.ts to reject non-object steps up front by checking the runtime
type of steps[i] (e.g., typeof step === 'object' && step !== null &&
!Array.isArray(step')) before treating it as a YamlStep; when the check fails
push an error or warning (consistent with existing errors/warnings arrays)
referencing the entry index, skip further processing for that entry (do not
increment autoIdCounter, add to seenIds, or call stepMap.set), and only cast to
YamlStep and continue validating type via VALID_TYPES once the runtime shape is
confirmed.

In `@web/src/pages/workflows/WorkflowTableView.tsx`:
- Around line 16-23: The formatDate function uses toLocaleDateString while also
passing time options; change it to use toLocaleString for idiomatic date+time
formatting: update function formatDate(iso: string) to call new
Date(iso).toLocaleString(...) with the same options (month, day, hour, minute)
so the output is produced using the conventional API for combined date and time.

---

Duplicate comments:
In `@web/src/pages/workflow-editor/ConditionExpressionBuilder.tsx`:
- Around line 483-500: handleModeChange drops parsed negate and subGroups when
switching from advanced to builder; update the else branch to use the values
returned by parseForBuilder (e.g., use flat.negate in setNegate and
flat.subGroups in setSubGroups) and preserve grouping/negation instead of
resetting them to false/[]; also include allocKey in the useCallback dependency
array so handleModeChange updates correctly when allocKey changes.
- Around line 198-210: The root AND/OR selector is hidden when there's only one
top-level row because SegmentedControl is only rendered inside ConditionRow
gated by showOperator; move or duplicate the SegmentedControl up into
ConditionExpressionBuilder so the root logicalOperator and onOperatorChange are
always visible for the top-level group (even when there is a single row or only
subgroups), and keep ConditionRow's SegmentedControl for non-root groups (or
remove the showOperator branch there if duplicating). Update props passed into
ConditionRow (logicalOperator, onOperatorChange) or lift rendering to
ConditionExpressionBuilder to ensure the selector controls the same
logicalOperator state used for serialization.

In `@web/src/pages/workflow-editor/yaml-to-nodes.ts`:
- Around line 23-39: Update the YAML->node import logic so it reads and
preserves explicit branch labels from the YAML depends_on entries (rather than
assigning "conditional_true"/"conditional_false" by encounter order): change the
handling around conditionalBranchCounters, String(rawDepId), and
sourceStep.step.condition to first parse an explicit edge label from the
depends_on item (if present) and attach that label to the created edge; only
fall back to inference (assigning true/false by index) when no explicit label
exists, and avoid collapsing conditional edges into sequential edges when
sourceStep.step.condition is temporarily empty by preserving any previously
assigned conditional edge metadata. Ensure this change is applied consistently
in the code paths around conditionalBranchCounters and the blocks referenced
(lines ~23-39, ~81-98, ~214-229) so explicit branch metadata survives reordering
and blank conditions.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@web/src/pages/workflow-editor/ConditionExpressionBuilder.tsx`:
- Around line 585-592: Replace the raw <input> in ConditionExpressionBuilder
with the shared InputField component: import InputField, use value={freeText}
and call handleFreeTextChange with the new value from InputField's
onChange/onValueChange (adapt to the component's prop signature), and pass the
existing placeholder, aria-label, className/styles and type="text" so styling
and form behavior remain identical; ensure you remove the raw input and add the
InputField import and wire up freeText and handleFreeTextChange accordingly.

In `@web/src/pages/workflow-editor/yaml-to-nodes.ts`:
- Around line 177-180: The parser currently treats unknown step types as
warnings so typos (e.g., "condtional") allow apply to proceed; change the
handling so unknown step types are recorded as hard parse errors that abort
apply: in the block using stepType and VALID_TYPES, replace the warnings.push
call with pushing a descriptive error into the same errors collection that
WorkflowYamlEditor checks (result.errors), e.g., add to errors (or
result.errors) with a message referencing the stepId and stepType and then
continue; ensure you use the existing symbols stepType, VALID_TYPES,
warnings/errors and that result.errors will be non-empty for unknown types.

In `@web/src/pages/workflows/WorkflowTableView.tsx`:
- Around line 70-71: In WorkflowTableView remove role="link" from the <tr>
(which overrides table semantics) and instead make the primary cell a real link:
wrap the clickable content for workflow w.name in an anchor inside the first
<td> (give it the existing aria-label={`Open workflow ${w.name}`} and ensure it
visually fills the cell via CSS/display so the row still appears clickable),
move any onKeyDown/onClick keyboard handlers to that anchor, and keep other
accessibility attributes (tabIndex, aria-selected, etc.) on the row only as
needed for selection not as a link.

---

Duplicate comments:
In `@web/src/pages/workflow-editor/ConditionExpressionBuilder.tsx`:
- Around line 61-76: buildExpression currently takes separate comparisons and
subGroups which loses root ordering; change it to accept a single ordered root
collection (e.g., rootItems: Array<{kind: 'comparison'|'group', comparison?:
ConditionComparison, group?: SubGroupEntry}> or simply
(ConditionComparison|SubGroupEntry)[]) so the original top-level order is
preserved, then iterate rootItems in order and for each item: if it's a
ConditionComparison push it to items, if it's a SubGroupEntry push either its
single comparison or createGroup(group.operator, group.entries.map(e =>
e.comparison)); finally return the single item if items.length === 1 else return
createGroup(logicalOperator, items). Ensure you update all call sites of
buildExpression (and the parameter names) accordingly to pass the ordered root
collection instead of separate comparisons/subGroups.

In `@web/src/pages/workflow-editor/yaml-to-nodes.ts`:
- Around line 230-232: The parser currently silently ignores non-array relation
fields and coerces relation items via String(rawDepId)/String(rawTarget), which
accepts objects/numbers and invents ids; update the relation handling in
yaml-to-nodes.ts so that when step.depends_on or step.branches is present but
not an Array you emit a parse error, and before constructing edges validate each
item (rawDepId/rawTarget) is a non-empty string (reject objects, numbers, null,
empty strings) and emit a parse error for invalid items instead of coercing;
apply this same validation logic to both depends_on and branches and perform
these checks prior to any edge construction or String(...) conversion.
- Around line 246-255: The dedupe key stored in emittedEdges (edgeKey) includes
edgeType while the created edge id (`id` property in the object pushed in edges
within edges.push) does not, causing collisions when the same source/target is
emitted with different relation types; update the logic so the emitted
uniqueness rule matches the id uniqueness rule: either (A) change the emitted
edgeKey to exclude edgeType (e.g., `${depId}->${stepId}`) so it deduplicates
exactly like the generated id, or (B) include edgeType in the generated edge id
(e.g., `edge-${depId}-${stepId}-${edgeType}`) and apply the same change in the
`branches` block as well (mirror this fix at the 277-283 area) so emittedEdges,
edgeKey, and the `id` created in edges.push use the same composition and mixed
duplicates are rejected consistently.
- Around line 23-39: YamlStep's depends_on currently only carries bare IDs
causing conditional_true/conditional_false assignment to depend on traversal
order; update the schema to allow explicit edge metadata (e.g., depends_on:
Array<{ id: string; condition?: 'true'|'false'|string; meta?: Record<string,any>
}>) while keeping the existing string[] form as a fallback, then modify the
YAML->node conversion logic (the function that maps YamlStep to graph nodes and
that currently sets conditional_true/conditional_false) to: 1) prefer the new
object form and use its condition/meta to deterministically assign
conditional_true/conditional_false edges, 2) if an entry is a string, preserve
current behavior for backward compatibility, and 3) ensure the export path emits
the explicit edge metadata when present so round-tripping remains stable.