@cat-factory/app 0.6.0

package/app/composables/api/recurring.ts

@@ -0,0 +1,68 @@
+import type { Service, WorkspaceMount } from '~/types/domain'
+import type {
+  CreateScheduleInput,
+  PipelineSchedule,
+  ScheduleRun,
+  UpdateScheduleInput,
+} from '~/types/recurring'
+import type { ApiContext, Position } from './context'
+
+/** Recurring (scheduled) pipelines + the in-org shared-service mount catalog. */
+export function recurringApi({ http, ws }: ApiContext) {
+  return {
+    // ---- recurring pipelines (scheduled runs against a service) -----------
+    listRecurringPipelines: (workspaceId: string) =>
+      http<PipelineSchedule[]>(`${ws(workspaceId)}/recurring-pipelines`),
+
+    createRecurringPipeline: (workspaceId: string, body: CreateScheduleInput) =>
+      http<PipelineSchedule>(`${ws(workspaceId)}/recurring-pipelines`, { method: 'POST', body }),
+
+    updateRecurringPipeline: (workspaceId: string, id: string, body: UpdateScheduleInput) =>
+      http<PipelineSchedule>(`${ws(workspaceId)}/recurring-pipelines/${encodeURIComponent(id)}`, {
+        method: 'PATCH',
+        body,
+      }),
+
+    deleteRecurringPipeline: (workspaceId: string, id: string) =>
+      http(`${ws(workspaceId)}/recurring-pipelines/${encodeURIComponent(id)}`, {
+        method: 'DELETE',
+      }),
+
+    listScheduleRuns: (workspaceId: string, id: string) =>
+      http<ScheduleRun[]>(`${ws(workspaceId)}/recurring-pipelines/${encodeURIComponent(id)}/runs`),
+
+    runScheduleNow: (workspaceId: string, id: string) =>
+      http<PipelineSchedule>(
+        `${ws(workspaceId)}/recurring-pipelines/${encodeURIComponent(id)}/run-now`,
+        { method: 'POST' },
+      ),
+
+    // ---- in-org shared services (mount/unmount + org catalog) -------------
+    // The services this workspace mounts, and the org catalog it can mount from. A 503
+    // means the feature isn't wired (the store hides its UI on any error here).
+    listServiceMounts: (workspaceId: string) =>
+      http<WorkspaceMount[]>(`${ws(workspaceId)}/services`),
+
+    listServiceCatalog: (workspaceId: string) =>
+      http<Service[]>(`${ws(workspaceId)}/services/catalog`),
+
+    mountService: (workspaceId: string, serviceId: string, body: { position?: Position } = {}) =>
+      http<WorkspaceMount>(`${ws(workspaceId)}/services/${encodeURIComponent(serviceId)}`, {
+        method: 'POST',
+        body,
+      }),
+
+    unmountService: (workspaceId: string, serviceId: string) =>
+      http(`${ws(workspaceId)}/services/${encodeURIComponent(serviceId)}`, { method: 'DELETE' }),
+
+    updateMountLayout: (
+      workspaceId: string,
+      serviceId: string,
+      body: { position?: Position; size?: { w: number; h: number } | null },
+    ) =>
+      http<WorkspaceMount>(`${ws(workspaceId)}/services/${encodeURIComponent(serviceId)}/layout`, {
+        method: 'PATCH',
+        body,
+      }),
+  }
+}

package/app/composables/api/releaseHealth.ts

@@ -0,0 +1,43 @@
+import type {
+  DatadogConnectionView,
+  ReleaseHealthConfig,
+  UpsertDatadogConnectionInput,
+  UpsertReleaseHealthConfigInput,
+} from '~/types/releaseHealth'
+import type { ApiContext } from './context'
+
+/** Datadog post-release-health: the connection + per-block monitor/SLO mapping. */
+export function releaseHealthApi({ http, ws }: ApiContext) {
+  return {
+    // ---- Datadog post-release-health settings -----------------------------
+    getDatadogConnection: (workspaceId: string) =>
+      http<DatadogConnectionView>(`${ws(workspaceId)}/datadog/connection`),
+
+    setDatadogConnection: (workspaceId: string, body: UpsertDatadogConnectionInput) =>
+      http<DatadogConnectionView>(`${ws(workspaceId)}/datadog/connection`, {
+        method: 'PUT',
+        body,
+      }),
+
+    deleteDatadogConnection: (workspaceId: string) =>
+      http(`${ws(workspaceId)}/datadog/connection`, { method: 'DELETE' }),
+
+    listReleaseHealthConfigs: (workspaceId: string) =>
+      http<ReleaseHealthConfig[]>(`${ws(workspaceId)}/release-health-configs`),
+
+    upsertReleaseHealthConfig: (
+      workspaceId: string,
+      blockId: string,
+      body: UpsertReleaseHealthConfigInput,
+    ) =>
+      http<ReleaseHealthConfig>(
+        `${ws(workspaceId)}/release-health-configs/${encodeURIComponent(blockId)}`,
+        { method: 'PUT', body },
+      ),
+
+    deleteReleaseHealthConfig: (workspaceId: string, blockId: string) =>
+      http(`${ws(workspaceId)}/release-health-configs/${encodeURIComponent(blockId)}`, {
+        method: 'DELETE',
+      }),
+  }
+}

package/app/composables/api/reviews.ts

@@ -0,0 +1,146 @@
+import type { ClarityReview, ResolveClarityExceededChoice } from '~/types/clarity'
+import type { ConsensusSession } from '~/types/consensus'
+import type {
+  RequirementReview,
+  ResolveRequirementsExceededChoice,
+  ReviewItemStatus,
+} from '~/types/requirements'
+import type { ApiContext } from './context'
+
+/**
+ * The two iterative gate reviewers (requirements + clarity) and the consensus
+ * session read. Each reviewer follows the same answer → incorporate → re-review
+ * → proceed/resolve-exceeded loop.
+ */
+export function reviewsApi({ http, ws }: ApiContext) {
+  return {
+    // ---- requirements review (stateless reviewer agent) ------------------
+    // The current review for a block (null when none has been run). A 503 means
+    // the feature is unconfigured (the panel hides on any error here).
+    getRequirementReview: (workspaceId: string, blockId: string) =>
+      http<RequirementReview | null>(
+        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/requirement-review`,
+      ),
+
+    // The latest consensus session for a block (`{ session: null }` when none / consensus
+    // off). The live transcript also arrives via the `consensus` stream event.
+    getConsensusSession: (workspaceId: string, blockId: string) =>
+      http<{ session: ConsensusSession | null }>(
+        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/consensus-session`,
+      ),
+
+    replyRequirementItem: (workspaceId: string, reviewId: string, itemId: string, reply: string) =>
+      http<RequirementReview>(
+        `${ws(workspaceId)}/requirement-reviews/${encodeURIComponent(reviewId)}/items/${encodeURIComponent(itemId)}/reply`,
+        { method: 'POST', body: { reply } },
+      ),
+
+    setRequirementItemStatus: (
+      workspaceId: string,
+      reviewId: string,
+      itemId: string,
+      status: ReviewItemStatus,
+    ) =>
+      http<RequirementReview>(
+        `${ws(workspaceId)}/requirement-reviews/${encodeURIComponent(reviewId)}/items/${encodeURIComponent(itemId)}`,
+        { method: 'PATCH', body: { status } },
+      ),
+
+    // Incorporate the answers ASYNCHRONOUSLY (every finding must be answered or dismissed).
+    // The durable driver folds them and re-reviews in the background. Optional `feedback` is
+    // the "do it differently" lever when redoing a merge. Returns the `incorporating` review
+    // at once; a notification calls the user back only if the re-review needs input.
+    incorporateRequirements: (workspaceId: string, blockId: string, feedback?: string) =>
+      http<RequirementReview>(
+        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/requirement-review/incorporate`,
+        { method: 'POST', body: feedback ? { feedback } : {} },
+      ),
+
+    // Re-review the incorporated document (one more reviewer pass). On convergence the
+    // parked run advances; otherwise the response carries the next cycle / cap state.
+    reReviewRequirements: (workspaceId: string, blockId: string) =>
+      http<RequirementReview>(
+        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/requirement-review/re-review`,
+        { method: 'POST' },
+      ),
+
+    // Proceed: settle the requirements and advance the parked run (all findings dismissed).
+    proceedRequirements: (workspaceId: string, blockId: string) =>
+      http<RequirementReview>(
+        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/requirement-review/proceed`,
+        { method: 'POST' },
+      ),
+
+    // Resolve a review that hit its iteration cap: extra-round / proceed / stop-reset.
+    resolveRequirementsExceeded: (
+      workspaceId: string,
+      blockId: string,
+      choice: ResolveRequirementsExceededChoice,
+    ) =>
+      http<RequirementReview>(
+        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/requirement-review/resolve-exceeded`,
+        { method: 'POST', body: { choice } },
+      ),
+
+    // ---- clarity review (bug-report triage reviewer agent) ---------------
+    // The current review for a block (null when none has been run). A 503 means
+    // the feature is unconfigured (the panel hides on any error here).
+    getClarityReview: (workspaceId: string, blockId: string) =>
+      http<ClarityReview | null>(
+        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/clarity-review`,
+      ),
+
+    replyClarityItem: (workspaceId: string, reviewId: string, itemId: string, reply: string) =>
+      http<ClarityReview>(
+        `${ws(workspaceId)}/clarity-reviews/${encodeURIComponent(reviewId)}/items/${encodeURIComponent(itemId)}/reply`,
+        { method: 'POST', body: { reply } },
+      ),
+
+    setClarityItemStatus: (
+      workspaceId: string,
+      reviewId: string,
+      itemId: string,
+      status: ReviewItemStatus,
+    ) =>
+      http<ClarityReview>(
+        `${ws(workspaceId)}/clarity-reviews/${encodeURIComponent(reviewId)}/items/${encodeURIComponent(itemId)}`,
+        { method: 'PATCH', body: { status } },
+      ),
+
+    // Incorporate the answers ASYNCHRONOUSLY (every finding must be answered or dismissed).
+    // The durable driver folds them and re-reviews in the background. Optional `feedback` is
+    // the "do it differently" lever when redoing a merge. Returns the `incorporating` review
+    // at once; a notification calls the user back only if the re-review needs input.
+    incorporateClarity: (workspaceId: string, blockId: string, feedback?: string) =>
+      http<ClarityReview>(
+        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/clarity-review/incorporate`,
+        { method: 'POST', body: feedback ? { feedback } : {} },
+      ),
+
+    // Re-review the clarified report (one more reviewer pass). On convergence the parked run
+    // advances; otherwise the response carries the next cycle / cap state.
+    reReviewClarity: (workspaceId: string, blockId: string) =>
+      http<ClarityReview>(
+        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/clarity-review/re-review`,
+        { method: 'POST' },
+      ),
+
+    // Proceed: settle the clarity review and advance the parked run (all findings dismissed).
+    proceedClarity: (workspaceId: string, blockId: string) =>
+      http<ClarityReview>(
+        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/clarity-review/proceed`,
+        { method: 'POST' },
+      ),
+
+    // Resolve a review that hit its iteration cap: extra-round / proceed / stop-reset.
+    resolveClarityExceeded: (
+      workspaceId: string,
+      blockId: string,
+      choice: ResolveClarityExceededChoice,
+    ) =>
+      http<ClarityReview>(
+        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/clarity-review/resolve-exceeded`,
+        { method: 'POST', body: { choice } },
+      ),
+  }
+}

package/app/composables/api/slack.ts

@@ -0,0 +1,54 @@
+import type {
+  SlackChannel,
+  SlackConnection,
+  SlackMemberMappingEntry,
+  SlackNotificationSettings,
+} from '~/types/slack'
+import type { ApiContext } from './context'
+
+/** Slack integration: per-account connection, per-workspace routing + member map. */
+export function slackApi({ http, ws }: ApiContext) {
+  return {
+    // ---- slack integration (extra notification transport) -----------------
+    // Per-account connection (manual bot-token paste + the OAuth "Add to Slack"
+    // URL), per-workspace routing, and the per-account member map. A 503 from
+    // `getSlackConnection` means the integration is off (the store hides its UI).
+    getSlackConnection: (workspaceId: string) =>
+      http<{ connection: SlackConnection | null; oauthEnabled: boolean }>(
+        `${ws(workspaceId)}/slack/connection`,
+      ),
+
+    getSlackInstallUrl: (workspaceId: string) =>
+      http<{ url: string }>(`${ws(workspaceId)}/slack/install-url`),
+
+    connectSlack: (workspaceId: string, token: string) =>
+      http<SlackConnection>(`${ws(workspaceId)}/slack/connect`, {
+        method: 'POST',
+        body: { token },
+      }),
+
+    disconnectSlack: (workspaceId: string) =>
+      http(`${ws(workspaceId)}/slack/connection`, { method: 'DELETE' }),
+
+    listSlackChannels: (workspaceId: string) =>
+      http<{ channels: SlackChannel[] }>(`${ws(workspaceId)}/slack/channels`),
+
+    getSlackSettings: (workspaceId: string) =>
+      http<SlackNotificationSettings>(`${ws(workspaceId)}/slack/settings`),
+
+    updateSlackSettings: (
+      workspaceId: string,
+      body: { routes: SlackNotificationSettings['routes']; mentionsEnabled: boolean },
+    ) =>
+      http<SlackNotificationSettings>(`${ws(workspaceId)}/slack/settings`, { method: 'PUT', body }),
+
+    getSlackMemberMapping: (workspaceId: string) =>
+      http<{ entries: SlackMemberMappingEntry[] }>(`${ws(workspaceId)}/slack/member-mapping`),
+
+    updateSlackMemberMapping: (workspaceId: string, entries: SlackMemberMappingEntry[]) =>
+      http<{ entries: SlackMemberMappingEntry[] }>(`${ws(workspaceId)}/slack/member-mapping`, {
+        method: 'PUT',
+        body: { entries },
+      }),
+  }
+}

package/app/composables/api/tasks.ts

@@ -0,0 +1,72 @@
+import type {
+  Block,
+  SourceTask,
+  TaskConnection,
+  TaskSearchResult,
+  TaskSourceDescriptor,
+  TaskSourceKind,
+} from '~/types/domain'
+import type { PutTrackerSettingsInput, TrackerSettings } from '~/types/tracker'
+import type { ApiContext } from './context'
+
+/** Task sources (Jira, …): connect/import/search/link + the workspace tracker selection. */
+export function tasksApi({ http, ws }: ApiContext) {
+  return {
+    // ---- task sources (Jira, …) ------------------------------------------
+    // The configured trackers + their connect/import metadata. A 503 means the
+    // integration is off (the store hides its UI on any error here).
+    listTaskSources: (workspaceId: string) =>
+      http<{ sources: TaskSourceDescriptor[] }>(`${ws(workspaceId)}/task-sources`),
+
+    listTaskConnections: (workspaceId: string) =>
+      http<{ connections: TaskConnection[] }>(`${ws(workspaceId)}/task-sources/connections`),
+
+    connectTaskSource: (
+      workspaceId: string,
+      source: TaskSourceKind,
+      credentials: Record<string, string>,
+    ) =>
+      http<TaskConnection>(`${ws(workspaceId)}/task-sources/${source}/connect`, {
+        method: 'POST',
+        body: { credentials },
+      }),
+
+    disconnectTaskSource: (workspaceId: string, source: TaskSourceKind) =>
+      http(`${ws(workspaceId)}/task-sources/${source}/connection`, { method: 'DELETE' }),
+
+    listTasks: (workspaceId: string) => http<SourceTask[]>(`${ws(workspaceId)}/tasks`),
+
+    importTask: (workspaceId: string, source: TaskSourceKind, body: { ref: string }) =>
+      http<SourceTask>(`${ws(workspaceId)}/task-sources/${source}/import`, {
+        method: 'POST',
+        body,
+      }),
+
+    searchTaskSource: (workspaceId: string, source: TaskSourceKind, query: string) =>
+      http<{ results: TaskSearchResult[] }>(`${ws(workspaceId)}/task-sources/${source}/search`, {
+        method: 'POST',
+        body: { query },
+      }),
+
+    linkTask: (
+      workspaceId: string,
+      body: { source: TaskSourceKind; externalId: string; blockId: string },
+    ) => http<SourceTask>(`${ws(workspaceId)}/tasks/link`, { method: 'POST', body }),
+
+    createTaskFromIssue: (
+      workspaceId: string,
+      body: { source: TaskSourceKind; externalId: string; containerId: string },
+    ) =>
+      http<{ block: Block; task: SourceTask }>(`${ws(workspaceId)}/tasks/create-block`, {
+        method: 'POST',
+        body,
+      }),
+
+    // ---- issue-tracker selection (workspace-level) ------------------------
+    getTrackerSettings: (workspaceId: string) =>
+      http<TrackerSettings>(`${ws(workspaceId)}/tracker-settings`),
+
+    putTrackerSettings: (workspaceId: string, body: PutTrackerSettingsInput) =>
+      http<TrackerSettings>(`${ws(workspaceId)}/tracker-settings`, { method: 'PUT', body }),
+  }
+}

package/app/composables/api/workspaces.ts

@@ -0,0 +1,36 @@
+import type {
+  UpdateWorkspaceSettingsInput,
+  Workspace,
+  WorkspaceSettings,
+  WorkspaceSnapshot,
+} from '~/types/domain'
+import type { ApiContext } from './context'
+
+/** Workspace CRUD + the full snapshot read. */
+export function workspacesApi({ http, ws }: ApiContext) {
+  return {
+    // ---- workspaces -------------------------------------------------------
+    listWorkspaces: () => http<Workspace[]>('/workspaces'),
+
+    createWorkspace: (
+      body: { name?: string; description?: string; seed?: boolean; accountId?: string } = {},
+    ) => http<WorkspaceSnapshot>('/workspaces', { method: 'POST', body }),
+
+    getWorkspace: (workspaceId: string) => http<WorkspaceSnapshot>(ws(workspaceId)),
+
+    updateWorkspace: (workspaceId: string, body: { name?: string; description?: string | null }) =>
+      http<Workspace>(ws(workspaceId), { method: 'PATCH', body }),
+
+    renameWorkspace: (workspaceId: string, name: string) =>
+      http<Workspace>(ws(workspaceId), { method: 'PATCH', body: { name } }),
+
+    deleteWorkspace: (workspaceId: string) => http(ws(workspaceId), { method: 'DELETE' }),
+
+    // ---- workspace runtime settings (human-wait escalation + per-service task limit) --
+    getWorkspaceSettings: (workspaceId: string) =>
+      http<WorkspaceSettings>(`${ws(workspaceId)}/settings`),
+
+    updateWorkspaceSettings: (workspaceId: string, body: UpdateWorkspaceSettingsInput) =>
+      http<WorkspaceSettings>(`${ws(workspaceId)}/settings`, { method: 'PUT', body }),
+  }
+}

package/app/composables/useApi.ts

@@ -0,0 +1,89 @@
+import type { FragmentOwnerKind } from '~/types/domain'
+import type { ApiContext } from './api/context'
+import { accountsApi } from './api/accounts'
+import { authApi } from './api/auth'
+import { bootstrapApi } from './api/bootstrap'
+import { boardApi } from './api/board'
+import { documentsApi } from './api/documents'
+import { executionApi } from './api/execution'
+import { fragmentsApi } from './api/fragments'
+import { githubApi } from './api/github'
+import { modelsApi } from './api/models'
+import { notificationsApi } from './api/notifications'
+import { presetsApi } from './api/presets'
+import { recurringApi } from './api/recurring'
+import { releaseHealthApi } from './api/releaseHealth'
+import { reviewsApi } from './api/reviews'
+import { slackApi } from './api/slack'
+import { tasksApi } from './api/tasks'
+import { workspacesApi } from './api/workspaces'
+
+/**
+ * Thin typed client over the cat-factory backend (a Hono worker). Every method
+ * maps to one REST endpoint; the request/response shapes mirror
+ * `@cat-factory/contracts`, so responses drop straight into the Pinia stores.
+ *
+ * The endpoints are grouped by domain into the `./api/*` factory modules; this
+ * function builds the shared {@link ApiContext} (the authed `$fetch` client +
+ * path/header helpers) and spreads every group into a single flat client, so
+ * call sites stay `useApi().someMethod(...)`.
+ *
+ * The base URL comes from runtime config (`NUXT_PUBLIC_API_BASE`), defaulting to
+ * the local wrangler dev server — see `nuxt.config.ts`.
+ */
+export function useApi() {
+  const apiBase = useRuntimeConfig().public.apiBase
+  const http = $fetch.create({
+    baseURL: apiBase,
+    // Attach the session token (when signed in) so the backend's auth gate lets
+    // the request through. Read lazily from the store so a fresh token applies
+    // without rebuilding the client.
+    onRequest({ options }) {
+      const token = useAuthStore().token
+      if (!token) return
+      const headers = new Headers(options.headers)
+      headers.set('Authorization', `Bearer ${token}`)
+      options.headers = headers
+    },
+    // A 401 means our token lapsed or was revoked — drop it so the UI re-gates.
+    onResponseError({ response }) {
+      if (response?.status === 401) useAuthStore().handleUnauthorized()
+    },
+  })
+
+  // The personal-subscription unlock password (individual-usage vendors) rides as an
+  // ambient request header — like the bearer token — so it never lands in a request
+  // body/wire-contract payload. Mirrors PERSONAL_PASSWORD_HEADER in @cat-factory/contracts.
+  const pwHeaders = (password?: string): Record<string, string> | undefined =>
+    password ? { 'X-Personal-Password': password } : undefined
+
+  const ws = (workspaceId: string) => `/workspaces/${encodeURIComponent(workspaceId)}`
+  // Prompt-fragment library routes exist at both tiers; resolve the prefix from
+  // the owner scope (ADR 0006 §8).
+  const scope = (kind: FragmentOwnerKind, id: string) =>
+    kind === 'account'
+      ? `/accounts/${encodeURIComponent(id)}`
+      : `/workspaces/${encodeURIComponent(id)}`
+
+  const ctx: ApiContext = { http, ws, scope, pwHeaders }
+
+  return {
+    ...authApi(ctx),
+    ...fragmentsApi(ctx),
+    ...modelsApi(ctx),
+    ...accountsApi(ctx),
+    ...workspacesApi(ctx),
+    ...boardApi(ctx),
+    ...executionApi(ctx),
+    ...documentsApi(ctx),
+    ...tasksApi(ctx),
+    ...reviewsApi(ctx),
+    ...notificationsApi(ctx),
+    ...presetsApi(ctx),
+    ...releaseHealthApi(ctx),
+    ...recurringApi(ctx),
+    ...githubApi(ctx),
+    ...slackApi(ctx),
+    ...bootstrapApi(ctx),
+  }
+}

package/app/composables/useBlockDrag.ts

@@ -0,0 +1,90 @@
+import { ref } from 'vue'
+import type { Block } from '~/types/domain'
+
+/**
+ * Pointer-driven dragging for blocks positioned inside a container's 2D canvas
+ * (tasks inside services/modules, modules inside services). Movement is divided
+ * by the board zoom so the block tracks the cursor. When `reparent` is set, the
+ * drop point is hit-tested against `[data-drop-zone]` ancestors so a task can be
+ * dragged from a service into a module (or back out).
+ */
+export function useBlockDrag() {
+  const board = useBoardStore()
+  const ui = useUiStore()
+  const draggingId = ref<string | null>(null)
+
+  function startDrag(
+    block: Block,
+    e: PointerEvent,
+    opts: { reparent?: boolean; clamp?: boolean } = {},
+  ) {
+    if (e.button !== 0) return
+    e.preventDefault()
+    e.stopPropagation()
+    const startX = e.clientX
+    const startY = e.clientY
+    const orig = { ...block.position }
+    // Container-local blocks (tasks/modules) are clamped to their parent's origin;
+    // frames live in free-floating flow space, so they opt out via `clamp: false`.
+    const clamp = opts.clamp ?? true
+    draggingId.value = block.id
+    // Position is only previewed locally while dragging and persisted once on
+    // release. Writing every move raced — a late, out-of-order response could land
+    // a stale position last and make the block jump after the user let go.
+    let moved = false
+    let last = orig
+
+    const onMove = (ev: PointerEvent) => {
+      const z = ui.zoom || 1
+      const nx = orig.x + (ev.clientX - startX) / z
+      const ny = orig.y + (ev.clientY - startY) / z
+      moved = true
+      last = { x: clamp ? Math.max(0, nx) : nx, y: clamp ? Math.max(0, ny) : ny }
+      board.previewMove(block.id, last)
+    }
+    const onUp = (ev: PointerEvent) => {
+      window.removeEventListener('pointermove', onMove)
+      window.removeEventListener('pointerup', onUp)
+      if (moved) {
+        // A successful reparent persists the move itself; otherwise commit the final
+        // position in place. Either way it's a single write, not one per frame. Run
+        // the hit-test BEFORE clearing draggingId so the dragged element is still
+        // marked non-interactive (see DraggableTask) and the zone beneath resolves.
+        const reparented = opts.reparent && reparentAt(block, ev.clientX, ev.clientY)
+        if (!reparented) void board.moveBlock(block.id, last)
+      }
+      draggingId.value = null
+    }
+    window.addEventListener('pointermove', onMove)
+    window.addEventListener('pointerup', onUp)
+  }
+
+  /** Returns true when the block was dropped into a *different* container. */
+  function reparentAt(block: Block, clientX: number, clientY: number): boolean {
+    const el = document.querySelector(`[data-block-id="${block.id}"]`) as HTMLElement | null
+    if (!el) return false
+    // The dragged block is already non-interactive while dragging (DraggableTask
+    // drops pointer-events on the whole wrapper, handle included); belt-and-braces,
+    // also neutralise this node so elementFromPoint resolves the zone beneath it.
+    const prev = el.style.pointerEvents
+    el.style.pointerEvents = 'none'
+    const under = document.elementFromPoint(clientX, clientY) as HTMLElement | null
+    const zoneEl = under?.closest('[data-drop-zone]') as HTMLElement | null
+    el.style.pointerEvents = prev
+    if (!zoneEl) return false
+
+    const newParent = zoneEl.getAttribute('data-drop-zone')!
+    if (newParent === block.parentId) return false // same container — caller commits position
+
+    const z = ui.zoom || 1
+    const zr = zoneEl.getBoundingClientRect()
+    const er = el.getBoundingClientRect()
+    void board.reparentBlock(block.id, newParent, {
+      x: Math.max(0, (er.left - zr.left) / z),
+      y: Math.max(0, (er.top - zr.top) / z),
+    })
+    return true
+  }
+
+  return { draggingId, startDrag }
+}