@cat-factory/app 0.153.2 → 0.153.4

package/app/stores/board/placement.ts

@@ -0,0 +1,203 @@
+import type { UpdateBlockInput } from '@cat-factory/contracts'
+import { useServicesStore } from '~/stores/services'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { BoardWriteContext } from './context'
+import { UNDO_WINDOW_MS } from './context'
+
+/**
+ * The board's placement (drag/drop/reparent) and per-block edit operations — the writes that
+ * move a block or patch its fields, including the dependency edges. Extracted from
+ * {@link createBoardMutations} (which keeps the creation writes) along the same seam: each
+ * closes over the shared {@link BoardWriteContext} so behaviour is identical to the original
+ * in-closure functions, and the split is purely to keep every function within the size budget.
+ */
+export function createBoardPlacement(ctx: BoardWriteContext) {
+  const { getBlock, upsert, api, toast, tr } = ctx
+
+  /**
+   * Move a block into a new container at a new local position. Drag-reparent commits
+   * silently on a small overshoot, so a successful move (into a *different* container,
+   * not an undo of one) offers a one-click undo back to its previous home.
+   */
+  async function reparentBlock(
+    id: string,
+    newParentId: string,
+    position: { x: number; y: number },
+    opts: { undoable?: boolean } = { undoable: true },
+  ) {
+    const b = getBlock(id)
+    const parent = getBlock(newParentId)
+    if (!b || !parent || b.id === newParentId) return
+    // tasks may live in services or modules; modules only in services
+    if (b.level === 'task' && parent.level !== 'frame' && parent.level !== 'module') return
+    if (b.level === 'module' && parent.level !== 'frame') return
+    // Optimistic: drop the block into the new container immediately so it doesn't
+    // briefly snap back to its old home while the request is in flight. Snapshot
+    // the old home so a rejected reparent restores it rather than leaving the
+    // block in the wrong container (a structural lie that survives until re-hydrate).
+    const prevParentId = b.parentId
+    const prevPosition = b.position
+    const name = b.title
+    b.parentId = newParentId
+    b.position = position
+    try {
+      upsert(
+        await api.reparentBlock(useWorkspaceStore().requireId(), id, {
+          parentId: newParentId,
+          position,
+        }),
+      )
+      // Offer an undo back to the previous container (a drag overshoot is easy). The undo
+      // move is itself non-undoable so the toast doesn't ping-pong.
+      if (opts.undoable && prevParentId) {
+        toast.add({
+          title: tr('board.toast.moved', { name }),
+          icon: 'i-lucide-move',
+          color: 'neutral',
+          duration: UNDO_WINDOW_MS,
+          actions: [
+            {
+              label: tr('common.undo'),
+              icon: 'i-lucide-undo-2',
+              onClick: () =>
+                void reparentBlock(id, prevParentId, prevPosition, { undoable: false }),
+            },
+          ],
+        })
+      }
+    } catch (e) {
+      b.parentId = prevParentId
+      b.position = prevPosition
+      toast.add({
+        title: tr('board.toast.moveFailed'),
+        description: e instanceof Error ? e.message : String(e),
+        icon: 'i-lucide-triangle-alert',
+        color: 'error',
+      })
+    }
+  }
+
+  /**
+   * Local-only optimistic position update during an active drag — no persistence.
+   * A drag fires this on every pointer move so the block tracks the cursor without
+   * a per-move API round-trip; the final position is committed once via
+   * {@link moveBlock} (or {@link reparentBlock}) on release. Persisting every move
+   * raced: out-of-order responses to the burst of in-flight writes could land a
+   * stale position last, snapping the block back after the user let go.
+   */
+  function previewMove(id: string, position: { x: number; y: number }) {
+    const b = getBlock(id)
+    if (b) b.position = position
+  }
+
+  async function moveBlock(id: string, position: { x: number; y: number }) {
+    const b = getBlock(id)
+    if (!b) return
+    const prevPosition = b.position
+    b.position = position // optimistic: keep the drag feeling instant
+    try {
+      // A mounted service frame's position is a PER-WORKSPACE layout override on the mount, not
+      // on the (shared) block — so route a frame drag there. Other moves write the block.
+      const services = useServicesStore()
+      const mount = services.serviceByFrameBlock[id]
+        ? services.byServiceId[services.serviceByFrameBlock[id]!.id]
+        : undefined
+      if (mount) {
+        await services.updateLayout(mount.serviceId, position)
+        return
+      }
+      upsert(await api.moveBlock(useWorkspaceStore().requireId(), id, { position }))
+    } catch (e) {
+      // Restore the pre-drag position — a rejected move must not leave the block at a
+      // spot the server never stored (a lie that survives until the next re-hydrate).
+      b.position = prevPosition
+      toast.add({
+        title: tr('board.toast.moveFailed'),
+        description: e instanceof Error ? e.message : String(e),
+        icon: 'i-lucide-triangle-alert',
+        color: 'error',
+      })
+    }
+  }
+
+  /** Patch the user-editable fields of a block (title, features, threshold…). */
+  async function updateBlock(id: string, patch: UpdateBlockInput) {
+    const b = getBlock(id)
+    if (!b) return
+    // Snapshot ONLY the fields this patch touches so a rejected write restores them exactly
+    // (a patch may set several at once) rather than leaving a stale optimistic value stuck on
+    // screen with no feedback — the same rollback contract the other mutations here follow.
+    const prev: Record<string, unknown> = {}
+    const patchRecord = patch as Record<string, unknown>
+    const record = b as unknown as Record<string, unknown>
+    for (const key of Object.keys(patch)) prev[key] = record[key]
+    Object.assign(b, patch) // optimistic
+    try {
+      upsert(await api.updateBlock(useWorkspaceStore().requireId(), id, patch))
+    } catch (e) {
+      // Re-resolve the block: a live event may have replaced its object reference (`upsert`
+      // swaps in a fresh one) while the write was in flight, so `b` can be stale. Only revert
+      // fields that still hold OUR optimistic value, so a newer server value that landed
+      // mid-flight isn't clobbered by the rollback.
+      const cur = getBlock(id) as unknown as Record<string, unknown> | undefined
+      if (cur) {
+        for (const key of Object.keys(patch)) {
+          if (cur[key] === patchRecord[key]) cur[key] = prev[key]
+        }
+      }
+      toast.add({
+        title: tr('board.toast.updateFailed'),
+        description: e instanceof Error ? e.message : String(e),
+        icon: 'i-lucide-triangle-alert',
+        color: 'error',
+      })
+    }
+  }
+
+  /**
+   * Toggle a dependency edge target -> source (target dependsOn source). The backend
+   * rejects an edge that would close a cycle (422) — surface that as a toast rather than
+   * letting it throw unhandled out of a board gesture.
+   */
+  async function toggleDependency(targetId: string, sourceId: string) {
+    if (targetId === sourceId || !getBlock(targetId)) return
+    try {
+      upsert(await api.toggleDependency(useWorkspaceStore().requireId(), targetId, { sourceId }))
+    } catch (e) {
+      toast.add({
+        title: tr('board.toast.linkFailed'),
+        description: e instanceof Error ? e.message : String(e),
+        icon: 'i-lucide-triangle-alert',
+        color: 'error',
+      })
+    }
+  }
+
+  /** Remove a dependency edge target -> source if it exists. */
+  async function removeDependency(targetId: string, sourceId: string) {
+    const t = getBlock(targetId)
+    if (!t || !t.dependsOn.includes(sourceId)) return
+    // the backend exposes a single toggle; the edge exists, so toggling removes it
+    try {
+      upsert(await api.toggleDependency(useWorkspaceStore().requireId(), targetId, { sourceId }))
+    } catch (e) {
+      // Mirror `toggleDependency`: a failure must surface (and leave the edge visible) rather
+      // than rejecting unhandled with no feedback.
+      toast.add({
+        title: tr('board.toast.unlinkFailed'),
+        description: e instanceof Error ? e.message : String(e),
+        icon: 'i-lucide-triangle-alert',
+        color: 'error',
+      })
+    }
+  }
+
+  return {
+    reparentBlock,
+    previewMove,
+    moveBlock,
+    updateBlock,
+    toggleDependency,
+    removeDependency,
+  }
+}

package/app/stores/board.ts

@@ -4,6 +4,7 @@ import type { Block } from '~/types/domain'
 import { useBlockQueries } from '~/composables/useBlockQueries'
 import type { PendingRemoval } from '~/stores/board/context'
 import { createBoardMutations } from '~/stores/board/mutations'
+import { createBoardPlacement } from '~/stores/board/placement'
 import { createBoardRemoval } from '~/stores/board/removal'
 
 /**
@@ -11,7 +12,8 @@ import { createBoardRemoval } from '~/stores/board/removal'
  * are owned by the backend — this store is a hydrated cache. Read getters are
  * pure client logic (see {@link useBlockQueries}); every mutation calls the API
  * and applies the authoritative block the server returns. The write operations
- * live in cohesive factories ({@link createBoardMutations} / {@link createBoardRemoval},
+ * live in cohesive factories ({@link createBoardMutations} / {@link createBoardPlacement} /
+ * {@link createBoardRemoval},
  * under `stores/board/`) that close over the shared state assembled here — a size-only
  * split, not a new seam.
  */
@@ -141,6 +143,7 @@ export const useBoardStore = defineStore('board', () => {
   // internal to the removal factory (only its delete toast wires it), so it is NOT re-exported.
   const context = { blocks, getBlock, upsert, pendingRemovals, pendingDoomed, api, toast, tr }
   const mutations = createBoardMutations(context)
+  const placement = createBoardPlacement(context)
   const { detach, reattach, removeBlock } = createBoardRemoval(context)
 
   return {
@@ -152,6 +155,7 @@ export const useBoardStore = defineStore('board', () => {
     upsert,
     ...queries,
     ...mutations,
+    ...placement,
     detach,
     reattach,
     removeBlock,

package/app/stores/execution/commands.ts

@@ -0,0 +1,197 @@
+import type { Ref } from 'vue'
+import type { ExecutionInstance, Pipeline } from '~/types/domain'
+import type { RequestStepChangesInput } from '@cat-factory/contracts'
+import type { IterationCapChoice } from '~/types/execution'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * Shared reactive state + injected dependencies the execution-store command factory closes
+ * over. Created once in the `execution` store setup and threaded into
+ * {@link createExecutionCommands} so the split operations stay behaviourally identical to the
+ * original single-closure store — a size-only extraction mirroring `stores/board/` and
+ * `stores/pipelines/`, not a new seam.
+ */
+export interface ExecutionCommandContext {
+  api: ReturnType<typeof useApi>
+  /** Centralised actionable toasts for run-control failures (see the store's note). */
+  runErrors: ReturnType<typeof usePipelineErrorToast>
+  instances: Ref<ExecutionInstance[]>
+}
+
+/**
+ * The run-control commands (start / decide / approve / merge / restart / cancel / stop) the
+ * execution store exposes. Each drives the backend and then refreshes the workspace snapshot,
+ * since advancing a run also rolls status/progress up onto its block server-side.
+ *
+ * Every command that can (re-)dispatch a step rides the initiator's personal password through
+ * `withCredential`, so an individual-usage (Claude/Codex) run re-mints its short-TTL activation
+ * while the user is present instead of breaking mid-pipeline.
+ */
+export function createExecutionCommands(ctx: ExecutionCommandContext) {
+  const { api, runErrors, instances } = ctx
+
+  /**
+   * Start `pipeline` against a block; the server marks the block in-progress. A block
+   * pinned to an individual-usage model (Claude) needs the initiator's personal
+   * password — supplied transparently from the local cache, and prompted via the
+   * credential modal (then retried) when the server replies 428.
+   */
+  async function start(blockId: string, pipeline: Pipeline): Promise<boolean> {
+    const ws = useWorkspaceStore()
+    const personal = usePersonalSubscriptionsStore()
+    // Returns false when the user cancels the personal-password prompt OR the start was
+    // refused (a 409 conflict, surfaced as an actionable toast here), so an optimistic
+    // caller can revert its "Starting…" state without its own error handling.
+    try {
+      return await personal.withCredential(async (password) => {
+        await api.startExecution(ws.requireId(), blockId, { pipelineId: pipeline.id }, password)
+        await ws.refresh()
+      })
+    } catch (e) {
+      runErrors.present(e, 'errors.action.startFailed')
+      return false
+    }
+  }
+
+  // Interacting with a running individual-usage run (resolve/approve/request-changes) advances
+  // + re-dispatches the run, so the server re-mints its short-TTL activation from the personal
+  // password first. It rides the cached password transparently, and — like start/retry — is
+  // gated through `withCredential`: a within-buffer/lapsed cache re-prompts EARLY here (while
+  // the user is present) rather than letting the run break mid-pipeline. For a non-individual
+  // run the server ignores it and nothing prompts.
+  async function resolveDecision(instanceId: string, decisionId: string, choice: string) {
+    const ws = useWorkspaceStore()
+    const personal = usePersonalSubscriptionsStore()
+    return await personal.withCredential(async (password) => {
+      await api.resolveDecision(ws.requireId(), instanceId, decisionId, { choice }, password)
+      await ws.refresh()
+    })
+  }
+
+  /** Approve a step's gated proposal (optionally edited); the run advances. */
+  async function approveStep(instanceId: string, approvalId: string, proposal?: string) {
+    const ws = useWorkspaceStore()
+    const personal = usePersonalSubscriptionsStore()
+    return await personal.withCredential(async (password) => {
+      await api.approveStep(ws.requireId(), instanceId, approvalId, { proposal }, password)
+      await ws.refresh()
+    })
+  }
+
+  /** Request changes on a gated proposal; the step re-runs with the review. */
+  async function requestStepChanges(
+    instanceId: string,
+    approvalId: string,
+    review: RequestStepChangesInput,
+  ) {
+    const ws = useWorkspaceStore()
+    const personal = usePersonalSubscriptionsStore()
+    return await personal.withCredential(async (password) => {
+      await api.requestStepChanges(ws.requireId(), instanceId, approvalId, review, password)
+      await ws.refresh()
+    })
+  }
+
+  /** Reject a gated proposal; the run stops entirely (a retryable failure). */
+  async function rejectStep(instanceId: string, approvalId: string, reason?: string) {
+    const ws = useWorkspaceStore()
+    await api.rejectStep(ws.requireId(), instanceId, approvalId, { reason })
+    await ws.refresh()
+  }
+
+  /**
+   * Resolve a companion step parked at its rework cap: extra-round (one more pass) /
+   * proceed (advance with the current output) / stop-reset (cancel + reset the task).
+   * Rides the cached personal password (gated through `withCredential`, so a within-buffer
+   * cache re-prompts early) for the server to re-mint the run's activation before
+   * re-dispatching on extra-round/proceed.
+   */
+  async function resolveCompanionExceeded(
+    instanceId: string,
+    approvalId: string,
+    choice: IterationCapChoice,
+  ) {
+    const ws = useWorkspaceStore()
+    const personal = usePersonalSubscriptionsStore()
+    return await personal.withCredential(async (password) => {
+      await api.resolveCompanionExceeded(
+        ws.requireId(),
+        instanceId,
+        approvalId,
+        { choice },
+        password,
+      )
+      await ws.refresh()
+    })
+  }
+
+  /** Merge an open PR (a task in `pr_ready`) — the server completes the task. */
+  async function mergePr(blockId: string) {
+    const ws = useWorkspaceStore()
+    try {
+      await api.mergeBlock(ws.requireId(), blockId)
+      await ws.refresh()
+    } catch (e) {
+      runErrors.present(e, 'errors.action.mergeFailed')
+    }
+  }
+
+  /**
+   * Restart a run from a chosen step: the server re-runs from `stepIndex` onward
+   * (resetting that step + later steps' iteration counters) while preserving the
+   * earlier steps' outputs as handoff context, and re-drives a fresh run. Like
+   * start/retry it may dispatch an individual-usage (Claude) step, so it rides the
+   * initiator's personal password — prompted (then retried) on a 428. Returns false
+   * when the user cancels that prompt (nothing was restarted).
+   */
+  async function restartFromStep(instanceId: string, stepIndex: number): Promise<boolean> {
+    const ws = useWorkspaceStore()
+    const personal = usePersonalSubscriptionsStore()
+    try {
+      return await personal.withCredential(async (password) => {
+        await api.restartFromStep(ws.requireId(), instanceId, stepIndex, password)
+        await ws.refresh()
+      })
+    } catch (e) {
+      runErrors.present(e, 'errors.action.restartFailed')
+      return false
+    }
+  }
+
+  /**
+   * Cancel the execution running against a block and reset it to planned. `workspaceId`
+   * defaults to the current workspace but can be pinned by callers that cancel a run for a
+   * board the user may have since navigated away from (e.g. a deferred delete's commit).
+   */
+  async function cancel(blockId: string, workspaceId?: string) {
+    const ws = useWorkspaceStore()
+    await api.cancelExecution(workspaceId ?? ws.requireId(), blockId)
+    instances.value = instances.value.filter((e) => e.blockId !== blockId)
+    await ws.refresh()
+  }
+
+  /**
+   * Stop a running execution WITHOUT deleting it: halts the container + durable driver
+   * and records the run as `cancelled` (a retryable failure), leaving the block
+   * `blocked`. Unlike {@link cancel} the run is kept — its steps/output stay readable on
+   * the board and it can be retried from where it stopped. `runId` is the execution id.
+   */
+  async function stop(runId: string) {
+    const ws = useWorkspaceStore()
+    await api.stopAgentRun(ws.requireId(), runId)
+    await ws.refresh()
+  }
+
+  return {
+    start,
+    resolveDecision,
+    approveStep,
+    requestStepChanges,
+    rejectStep,
+    resolveCompanionExceeded,
+    restartFromStep,
+    mergePr,
+    cancel,
+    stop,
+  }
+}

package/app/stores/execution.ts

@@ -1,21 +1,17 @@
 import { defineStore } from 'pinia'
 import { ref, computed } from 'vue'
-import type {
-  Decision,
-  ExecutionInstance,
-  Pipeline,
-  PipelineStep,
-  StepApproval,
-} from '~/types/domain'
-import type { RequestStepChangesInput } from '@cat-factory/contracts'
-import type { IterationCapChoice } from '~/types/execution'
-import { useWorkspaceStore } from '~/stores/workspace'
+import type { Decision, ExecutionInstance, PipelineStep, StepApproval } from '~/types/domain'
+import { createExecutionCommands } from '~/stores/execution/commands'
 
 /**
  * Running pipeline instances. The simulation engine lives on the backend: this
  * store mirrors the server's executions and drives them via the API. Commands
  * call the worker and then refresh the workspace snapshot, since advancing an
  * execution also rolls status/progress up onto its block server-side.
+ *
+ * The run-control commands live in a cohesive factory ({@link createExecutionCommands}, under
+ * `stores/execution/`) that closes over the state assembled here — a size-only split mirroring
+ * `stores/board/`, not a new seam.
  */
 export const useExecutionStore = defineStore('execution', () => {
   const api = useApi()
@@ -225,101 +221,6 @@ export const useExecutionStore = defineStore('execution', () => {
   const decisionsByBlock = computed(() => groupByBlock(openDecisions.value))
   const approvalsByBlock = computed(() => groupByBlock(openApprovals.value))
 
-  /**
-   * Start `pipeline` against a block; the server marks the block in-progress. A block
-   * pinned to an individual-usage model (Claude) needs the initiator's personal
-   * password — supplied transparently from the local cache, and prompted via the
-   * credential modal (then retried) when the server replies 428.
-   */
-  async function start(blockId: string, pipeline: Pipeline): Promise<boolean> {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    // Returns false when the user cancels the personal-password prompt OR the start was
-    // refused (a 409 conflict, surfaced as an actionable toast here), so an optimistic
-    // caller can revert its "Starting…" state without its own error handling.
-    try {
-      return await personal.withCredential(async (password) => {
-        await api.startExecution(ws.requireId(), blockId, { pipelineId: pipeline.id }, password)
-        await ws.refresh()
-      })
-    } catch (e) {
-      runErrors.present(e, 'errors.action.startFailed')
-      return false
-    }
-  }
-
-  // Interacting with a running individual-usage run (resolve/approve/request-changes) advances
-  // + re-dispatches the run, so the server re-mints its short-TTL activation from the personal
-  // password first. It rides the cached password transparently, and — like start/retry — is
-  // gated through `withCredential`: a within-buffer/lapsed cache re-prompts EARLY here (while
-  // the user is present) rather than letting the run break mid-pipeline. For a non-individual
-  // run the server ignores it and nothing prompts.
-  async function resolveDecision(instanceId: string, decisionId: string, choice: string) {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    return await personal.withCredential(async (password) => {
-      await api.resolveDecision(ws.requireId(), instanceId, decisionId, { choice }, password)
-      await ws.refresh()
-    })
-  }
-
-  /** Approve a step's gated proposal (optionally edited); the run advances. */
-  async function approveStep(instanceId: string, approvalId: string, proposal?: string) {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    return await personal.withCredential(async (password) => {
-      await api.approveStep(ws.requireId(), instanceId, approvalId, { proposal }, password)
-      await ws.refresh()
-    })
-  }
-
-  /** Request changes on a gated proposal; the step re-runs with the review. */
-  async function requestStepChanges(
-    instanceId: string,
-    approvalId: string,
-    review: RequestStepChangesInput,
-  ) {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    return await personal.withCredential(async (password) => {
-      await api.requestStepChanges(ws.requireId(), instanceId, approvalId, review, password)
-      await ws.refresh()
-    })
-  }
-
-  /** Reject a gated proposal; the run stops entirely (a retryable failure). */
-  async function rejectStep(instanceId: string, approvalId: string, reason?: string) {
-    const ws = useWorkspaceStore()
-    await api.rejectStep(ws.requireId(), instanceId, approvalId, { reason })
-    await ws.refresh()
-  }
-
-  /**
-   * Resolve a companion step parked at its rework cap: extra-round (one more pass) /
-   * proceed (advance with the current output) / stop-reset (cancel + reset the task).
-   * Rides the cached personal password (gated through `withCredential`, so a within-buffer
-   * cache re-prompts early) for the server to re-mint the run's activation before
-   * re-dispatching on extra-round/proceed.
-   */
-  async function resolveCompanionExceeded(
-    instanceId: string,
-    approvalId: string,
-    choice: IterationCapChoice,
-  ) {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    return await personal.withCredential(async (password) => {
-      await api.resolveCompanionExceeded(
-        ws.requireId(),
-        instanceId,
-        approvalId,
-        { choice },
-        password,
-      )
-      await ws.refresh()
-    })
-  }
-
   /** How many approval gates anywhere are awaiting a human. */
   const pendingApprovalCount = computed(() =>
     instances.value.reduce(
@@ -328,62 +229,11 @@ export const useExecutionStore = defineStore('execution', () => {
     ),
   )
 
-  /** Merge an open PR (a task in `pr_ready`) — the server completes the task. */
-  async function mergePr(blockId: string) {
-    const ws = useWorkspaceStore()
-    try {
-      await api.mergeBlock(ws.requireId(), blockId)
-      await ws.refresh()
-    } catch (e) {
-      runErrors.present(e, 'errors.action.mergeFailed')
-    }
-  }
-
-  /**
-   * Restart a run from a chosen step: the server re-runs from `stepIndex` onward
-   * (resetting that step + later steps' iteration counters) while preserving the
-   * earlier steps' outputs as handoff context, and re-drives a fresh run. Like
-   * start/retry it may dispatch an individual-usage (Claude) step, so it rides the
-   * initiator's personal password — prompted (then retried) on a 428. Returns false
-   * when the user cancels that prompt (nothing was restarted).
-   */
-  async function restartFromStep(instanceId: string, stepIndex: number): Promise<boolean> {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    try {
-      return await personal.withCredential(async (password) => {
-        await api.restartFromStep(ws.requireId(), instanceId, stepIndex, password)
-        await ws.refresh()
-      })
-    } catch (e) {
-      runErrors.present(e, 'errors.action.restartFailed')
-      return false
-    }
-  }
-
-  /**
-   * Cancel the execution running against a block and reset it to planned. `workspaceId`
-   * defaults to the current workspace but can be pinned by callers that cancel a run for a
-   * board the user may have since navigated away from (e.g. a deferred delete's commit).
-   */
-  async function cancel(blockId: string, workspaceId?: string) {
-    const ws = useWorkspaceStore()
-    await api.cancelExecution(workspaceId ?? ws.requireId(), blockId)
-    instances.value = instances.value.filter((e) => e.blockId !== blockId)
-    await ws.refresh()
-  }
-
-  /**
-   * Stop a running execution WITHOUT deleting it: halts the container + durable driver
-   * and records the run as `cancelled` (a retryable failure), leaving the block
-   * `blocked`. Unlike {@link cancel} the run is kept — its steps/output stay readable on
-   * the board and it can be retried from where it stopped. `runId` is the execution id.
-   */
-  async function stop(runId: string) {
-    const ws = useWorkspaceStore()
-    await api.stopAgentRun(ws.requireId(), runId)
-    await ws.refresh()
-  }
+  // The run-control commands (start / decide / approve / merge / restart / cancel / stop),
+  // extracted into a cohesive factory sharing the state above (a size-only split mirroring
+  // `stores/board/` and `stores/pipelines/` — behaviour is identical to the former in-closure
+  // functions).
+  const commands = createExecutionCommands({ api, runErrors, instances })
 
   return {
     instances,
@@ -398,15 +248,6 @@ export const useExecutionStore = defineStore('execution', () => {
     decisionsByBlock,
     approvalsByBlock,
     pendingApprovalCount,
-    start,
-    resolveDecision,
-    approveStep,
-    requestStepChanges,
-    rejectStep,
-    resolveCompanionExceeded,
-    restartFromStep,
-    mergePr,
-    cancel,
-    stop,
+    ...commands,
   }
 })