npm - @cat-factory/app - Versions diffs - 0.192.0 → 0.194.0 - Mend

@cat-factory/app 0.192.0 → 0.194.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

package/app/components/board/AddTaskModal.vue +7 -5
package/app/components/board/RecurringPipelineModal.vue +11 -6
package/app/components/board/nodes/BlockNode.vue +28 -46
package/app/components/board/nodes/ModuleFrame.vue +4 -33
package/app/components/board/nodes/ResizeGrips.vue +130 -0
package/app/components/focus/BlockFocusView.vue +11 -3
package/app/components/panels/InspectorPanel.vue +15 -4
package/app/components/panels/inspector/TaskRunSettings.vue +5 -1
package/app/components/requirements/RequirementsReviewWindow.vue +34 -0
package/app/composables/api/board.ts +7 -1
package/app/composables/api/context.ts +2 -0
package/app/composables/useFrameResize.ts +116 -22
package/app/composables/usePipelineHealth.spec.ts +32 -0
package/app/composables/usePipelineHealth.ts +23 -4
package/app/stores/board/placement.ts +64 -1
package/app/stores/board.spec.ts +51 -0
package/app/types/requirements.ts +1 -0
package/app/utils/pipeline.spec.ts +85 -5
package/app/utils/pipeline.ts +32 -11
package/i18n/locales/de.json +7 -1
package/i18n/locales/en.json +11 -1
package/i18n/locales/es.json +7 -1
package/i18n/locales/fr.json +7 -1
package/i18n/locales/he.json +7 -1
package/i18n/locales/it.json +7 -1
package/i18n/locales/ja.json +7 -1
package/i18n/locales/pl.json +7 -1
package/i18n/locales/tr.json +7 -1
package/i18n/locales/uk.json +7 -1
package/package.json +2 -2

package/app/composables/useFrameResize.ts CHANGED Viewed

@@ -2,56 +2,150 @@ import { ref } from 'vue'
 import type { Block } from '~/types/domain'
 /**
- * Pointer-driven resizing for service frames (Miro-style border drag). The drag
- * delta is divided by the board zoom so the edge tracks the cursor, and the new
- * size is clamped to the frame's content extent so dragging in never clips the
- * tasks/modules inside. The frame grows live (the store block is mutated in place,
- * which `containerSize` reads back), and the final size is persisted once on
- * release rather than on every move.
+ * The eight border/corner grips, each as the pair of unit factors saying how far the drag moves
+ * the container's ORIGIN versus its far edge. `1` on an origin axis means that axis's border is
+ * the one being dragged (west/north), so the box grows the OPPOSITE way from the pointer delta.
+ *
+ * Encoding the geometry as data rather than a `switch` per axis is what keeps the corners honest:
+ * `nw` is exactly `n` and `w` applied together, and there is no eighth case to forget.
+ */
+const HANDLES = {
+  n: { ox: 0, oy: 1, sx: 0, sy: -1, cursor: 'ns-resize' },
+  s: { ox: 0, oy: 0, sx: 0, sy: 1, cursor: 'ns-resize' },
+  e: { ox: 0, oy: 0, sx: 1, sy: 0, cursor: 'ew-resize' },
+  w: { ox: 1, oy: 0, sx: -1, sy: 0, cursor: 'ew-resize' },
+  ne: { ox: 0, oy: 1, sx: 1, sy: -1, cursor: 'nesw-resize' },
+  nw: { ox: 1, oy: 1, sx: -1, sy: -1, cursor: 'nwse-resize' },
+  se: { ox: 0, oy: 0, sx: 1, sy: 1, cursor: 'nwse-resize' },
+  sw: { ox: 1, oy: 0, sx: -1, sy: 1, cursor: 'nesw-resize' },
+} as const
+export type ResizeEdge = keyof typeof HANDLES
+/** The grips in render order, so a component can `v-for` them instead of listing eight blocks. */
+export const RESIZE_EDGES = Object.keys(HANDLES) as ResizeEdge[]
+/** The `cursor` a given grip shows, and holds on `<body>` while its drag runs. */
+export function resizeCursor(edge: ResizeEdge): string {
+  return HANDLES[edge].cursor
+}
+/**
+ * Pointer-driven resizing for containers (service frames and modules) by dragging any border or
+ * corner, Miro-style. The drag delta is divided by the board zoom so the border tracks the
+ * cursor, and the new size is clamped to the container's content extent so dragging inwards never
+ * clips the tasks/modules inside.
+ *
+ * Dragging the north or west border also moves the container's ORIGIN, and a child's position is
+ * stored relative to that origin — so the store translates the children by the inverse (see
+ * `previewResize`) and the backend does the same on commit, which is what makes the border extend
+ * past the contents instead of dragging them along. The origin is derived from the CLAMPED size
+ * rather than from the raw pointer delta: once the box has hit its content floor the border must
+ * stop dead, and a separately-clamped origin would keep sliding, walking the whole container
+ * across the board.
+ *
+ * The container grows live off the store's optimistic geometry, and the final bounds are
+ * persisted ONCE on release rather than on every move.
  */
 export function useFrameResize() {
   const board = useBoardStore()
   const ui = useUiStore()
   const access = useWorkspaceAccess()
-  /** Id of the frame currently being resized, for cursor/handle styling. */
+  /** Id of the container currently being resized, for cursor/grip styling. */
   const resizingId = ref<string | null>(null)
   /**
-   * Begin a resize from one of the frame's edges/corner. `edge` selects which
-   * dimensions move: `'e'` width only, `'s'` height only, `'se'` both.
+   * How far the origin may travel INWARD before the nearest child would land at a negative
+   * offset — i.e. outside the box, spilling over the very border being dragged. `contentSize` is
+   * no help here: it measures only the FAR edge of the contents, which a north/west shrink moves
+   * inward in step with the border, so nothing there ever objects. `Infinity` for an empty
+   * container, which is then bounded by `contentSize`'s empty floor alone.
    */
-  function startResize(block: Block, e: PointerEvent, edge: 'e' | 's' | 'se') {
+  function originSlack(id: string): { x: number; y: number } {
+    const children = board.childrenOf(id)
+    if (!children.length) return { x: Number.POSITIVE_INFINITY, y: Number.POSITIVE_INFINITY }
+    return {
+      x: Math.min(...children.map((c) => c.position.x)),
+      y: Math.min(...children.map((c) => c.position.y)),
+    }
+  }
+  /** Begin a resize from one of the container's borders or corners. */
+  function startResize(block: Block, e: PointerEvent, edge: ResizeEdge) {
     if (e.button !== 0) return
-    // Resizing a frame persists its size — a `board.write` mutation, so a read-only
-    // viewer's resize no-ops (the grips are hidden for them at the component level).
+    // Resizing persists geometry — a `board.write` mutation, so a read-only viewer's resize
+    // no-ops (the grips are hidden for them at the component level).
     if (!access.canWriteBoard.value) return
     e.preventDefault()
     e.stopPropagation()
+    const handle = HANDLES[edge]
     const startX = e.clientX
     const startY = e.clientY
-    // The content extent is the floor — never shrink a frame below its tasks.
-    const min = board.contentSize(block.id)
-    // Seed from the current rendered size so the first move doesn't jump.
+    // Seed from the current rendered geometry so the first move doesn't jump. `size` may be
+    // absent (an auto-sized container), which is also what a rejected resize must restore.
     const start = board.containerSize(block.id)
+    const from = {
+      position: { ...block.position },
+      size: block.size ? { ...block.size } : undefined,
+    }
+    // The floors, snapshotted once: on an origin-axis drag the children MOVE, so a floor re-read
+    // mid-drag would chase them. `contentSize` bounds the far edge; the near-edge bound applies
+    // only where the origin travels, and only inwards.
+    const min = board.contentSize(block.id)
+    const slack = originSlack(block.id)
+    const floor = {
+      w: handle.ox ? Math.max(min.w, start.w - slack.x) : min.w,
+      h: handle.oy ? Math.max(min.h, start.h - slack.y) : min.h,
+    }
     resizingId.value = block.id
+    // Hold the resize cursor on `<body>` (and kill text selection) for the whole drag: the
+    // pointer routinely outruns the 12px grip, and without this the cursor flips back to the
+    // default mid-drag, which reads as "the grab was dropped" even though the border is still
+    // tracking.
+    const body = document.body
+    const priorCursor = body.style.cursor
+    const priorUserSelect = body.style.userSelect
+    body.style.cursor = handle.cursor
+    body.style.userSelect = 'none'
+    let bounds = { position: from.position, size: start }
+    let moved = false
     const onMove = (ev: PointerEvent) => {
       const z = ui.zoom || 1
-      const w = edge === 's' ? start.w : Math.max(min.w, start.w + (ev.clientX - startX) / z)
-      const h = edge === 'e' ? start.h : Math.max(min.h, start.h + (ev.clientY - startY) / z)
-      // Optimistic, local-only: mutate the cached block so the frame grows live
-      // without a round-trip on every pointer move.
-      block.size = { w: Math.round(w), h: Math.round(h) }
+      const dx = (ev.clientX - startX) / z
+      const dy = (ev.clientY - startY) / z
+      const w = Math.round(Math.max(floor.w, start.w + handle.sx * dx))
+      const h = Math.round(Math.max(floor.h, start.h + handle.sy * dy))
+      // A grown box on an origin axis extends BACKWARDS from where the far edge stays put, so
+      // the origin moves by whatever the size actually gained after clamping.
+      bounds = {
+        position: {
+          x: from.position.x - handle.ox * (w - start.w),
+          y: from.position.y - handle.oy * (h - start.h),
+        },
+        size: { w, h },
+      }
+      moved = true
+      // Optimistic, local-only (the store also translates the children): no round-trip per move.
+      board.previewResize(block.id, bounds.position, bounds.size)
     }
     const onUp = () => {
       window.removeEventListener('pointermove', onMove)
       window.removeEventListener('pointerup', onUp)
+      window.removeEventListener('pointercancel', onUp)
+      body.style.cursor = priorCursor
+      body.style.userSelect = priorUserSelect
       resizingId.value = null
-      // Persist the final size once (also re-applies it as the authoritative block).
-      if (block.size) void board.updateBlock(block.id, { size: block.size })
+      // A press with no movement is not a resize: committing it would emit a coarse board signal
+      // (every other client re-hydrates) to store the geometry it already had.
+      if (moved) void board.resizeBlock(block.id, bounds, from)
     }
     window.addEventListener('pointermove', onMove)
     window.addEventListener('pointerup', onUp)
+    // A cancelled pointer (touch interrupted by a gesture, window losing the pointer) never fires
+    // `pointerup`, so without this the body cursor stays stuck on `ew-resize` for the session.
+    window.addEventListener('pointercancel', onUp)
   }
   return { resizingId, startResize }

package/app/composables/usePipelineHealth.spec.ts CHANGED Viewed

@@ -140,6 +140,38 @@ describe('usePipelineHealth', () => {
     expect(invalid.value[0]!.problems.some((p) => p.type === 'shape')).toBe(true)
   })
+  // The regression this pins: the advisory carried its own "only a companion may be gated" rule,
+  // so when the engine generalised gating to `BUILTIN_GATABLE_KINDS` the shipped `pl_simple`
+  // ("Adaptive build" — an estimate-gated `architect`) was reported invalid in EVERY workspace.
+  // Because the advisory auto-opens a modal over the board, that made the board unusable rather
+  // than merely warning wrongly. Both sides now read the shared contracts constant.
+  it('accepts an estimate-gated NON-companion producer that the shared gatable set allows', () => {
+    const adaptive = builtin(['task-estimator', 'architect', 'architect-companion', 'coder'], {
+      gating: [null, { enabled: true, minComplexity: 0.4, onMissingEstimate: 'run' }, null, null],
+    })
+    const { hasIssues } = scan([adaptive])
+    expect(hasIssues.value).toBe(false)
+  })
+  it('still flags an estimate-gated kind the shared gatable set excludes (merger)', () => {
+    const gatedMerger = builtin(['task-estimator', 'coder', 'merger'], {
+      gating: [null, null, { enabled: true, minComplexity: 0.4, onMissingEstimate: 'run' }],
+    })
+    const { invalid } = scan([gatedMerger])
+    expect(invalid.value).toHaveLength(1)
+    expect(invalid.value[0]!.problems.some((p) => p.type === 'shape')).toBe(true)
+  })
+  it('flags a step carrying BOTH a human approval gate and an estimate gate (shape)', () => {
+    const both = builtin(['task-estimator', 'architect'], {
+      gates: [false, true],
+      gating: [null, { enabled: true, minComplexity: 0.4, onMissingEstimate: 'run' }],
+    })
+    const { invalid } = scan([both])
+    expect(invalid.value).toHaveLength(1)
+    expect(invalid.value[0]!.problems.some((p) => p.type === 'shape')).toBe(true)
+  })
   it('reports a built-in whose catalog version moved ahead as outdated (not invalid)', () => {
     const stale = builtin(['coder', 'reviewer'], { id: 'pl_stale', version: 1 })
     const { invalid, outdated } = scan([stale], { pl_stale: 2 })

package/app/composables/usePipelineHealth.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import { computed } from 'vue'
 import type { Pipeline } from '~/types/domain'
 import type { StepGating } from '~/types/consensus'
+import { isBuiltinGatableKind } from '@cat-factory/contracts'
 import { COMPANION_FOR_PRODUCER, isKnownAgentKind, isProducerCompanion } from '~/utils/catalog'
 import { usePipelinesStore } from '~/stores/pipelines'
@@ -78,6 +79,11 @@ const isEnabledAt = (p: Pipeline, i: number) => p.enabled?.[i] !== false
  * gating, over the ENABLED subset), collecting the first problem instead of throwing. Returns a
  * human message, or null when the shape is valid. Kept in step with
  * `backend/packages/orchestration/src/modules/pipelines/pipelineShape.ts`.
+ *
+ * A rule here must be keyed off vocabulary SHARED with that module (`@cat-factory/contracts`)
+ * wherever one exists, never re-stated locally — see the gating note below for what a drifted copy
+ * costs. Adding a rule to `assertValidGating` without adding it here is the milder half of the same
+ * drift: a pipeline the engine refuses at save that this advisory calls healthy.
  */
 function shapeProblem(p: Pipeline): string | null {
   const kinds = p.agentKinds
@@ -102,16 +108,29 @@ function shapeProblem(p: Pipeline): string | null {
       return `Companion '${kind}' must run immediately after an enabled step it can review (${targets.join(', ')}).`
     }
   }
-  // Estimate gating: an enabled gated step must be a companion, set ≥1 threshold, and have an
-  // enabled task-estimator earlier in the chain.
+  // Estimate gating: an enabled gated step must be a GATABLE kind, must not also carry a human
+  // approval gate, must set ≥1 threshold, and must have an enabled task-estimator earlier in the
+  // chain. Gatability reads the SHARED `BUILTIN_GATABLE_KINDS` rather than a local rule, because
+  // this advisory auto-opens a modal over the board: a copy of the rule that drifts behind the
+  // engine's does not merely warn wrongly, it calls a pipeline the product SHIPS invalid and leaves
+  // the board unusable. A DEPLOYMENT-registered kind can override gatability for itself through the
+  // agent-kind registry, which the SPA cannot see, so the two are not perfectly symmetric: such a
+  // kind is reported here and accepted by the engine. That is the safe direction of the asymmetry —
+  // a dismissible advisory rather than a refused save — and the only one available without shipping
+  // the registry to the browser.
   const gating = p.gating
   if (gating) {
     for (let i = 0; i < kinds.length; i++) {
       const g = gating[i] as StepGating | null | undefined
       if (!g?.enabled || !isEnabledAt(p, i)) continue
       const kind = kinds[i]
-      if (!kind || !isProducerCompanion(kind)) {
-        return `Step '${kind}' cannot be estimate-gated — only companion steps may be skipped on the estimate.`
+      if (!kind || !isBuiltinGatableKind(kind)) {
+        return `Step '${kind}' may not be estimate-gated — its output is required by the rest of the run. Only a step whose result later steps read as context (a design, a review, an extra verification pass) may be skipped on the estimate.`
+      }
+      // A human approval gate and an estimate gate on the same step contradict: the estimate may
+      // ADD a human checkpoint but never CANCEL a pause the pipeline author asked for.
+      if (p.gates?.[i] === true) {
+        return `Step '${kind}' carries a human approval gate, so it cannot also be estimate-gated — the estimate may add a human checkpoint but never remove one.`
       }
       if (g.minComplexity === undefined && g.minRisk === undefined && g.minImpact === undefined) {
         return `Step '${kind}' is estimate-gated but sets no threshold (complexity / risk / impact).`

package/app/stores/board/placement.ts CHANGED Viewed

@@ -12,7 +12,7 @@ import { UNDO_WINDOW_MS } from './context'
  * 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
+  const { blocks, getBlock, upsert, api, toast, tr } = ctx
   /**
    * Move a block into a new container at a new local position. Drag-reparent commits
@@ -120,6 +120,67 @@ export function createBoardPlacement(ctx: BoardWriteContext) {
     }
   }
+  /**
+   * Translate every DIRECT child of a container — the client half of the compensation the
+   * backend's `shiftChildPositions` applies. A child's position is relative to its container's
+   * content origin, so moving that origin (a north/west border drag) has to move the children
+   * the other way or the contents slide with the border. Grandchildren ride their module.
+   */
+  function shiftChildren(parentId: string, dx: number, dy: number) {
+    if (!dx && !dy) return
+    for (const child of blocks.value) {
+      if (child.parentId !== parentId) continue
+      child.position = { x: child.position.x + dx, y: child.position.y + dy }
+    }
+  }
+  /**
+   * Local-only geometry update during an active border drag — the resize counterpart of
+   * {@link previewMove}, and for the same reason: persisting every pointer move would let an
+   * out-of-order response land a stale size after the user let go. Takes ABSOLUTE bounds and
+   * derives the origin delta itself, so a caller can drive it from a running drag without
+   * tracking what it has already applied. {@link resizeBlock} commits the final bounds once.
+   */
+  function previewResize(
+    id: string,
+    position: { x: number; y: number },
+    size?: { w: number; h: number },
+  ) {
+    const b = getBlock(id)
+    if (!b) return
+    shiftChildren(id, b.position.x - position.x, b.position.y - position.y)
+    b.position = position
+    b.size = size
+  }
+  /**
+   * Commit a border-drag resize: ONE call carrying both halves of the geometry, because only an
+   * operation that sees the origin delta can translate the container's children with it (see
+   * `BoardService.resizeBlock`). `from` is the pre-drag geometry — a rejected resize replays it
+   * through {@link previewResize}, which undoes the child translation by the same arithmetic that
+   * applied it, so a failure can't leave the contents offset from a box the server never stored.
+   */
+  async function resizeBlock(
+    id: string,
+    bounds: { position: { x: number; y: number }; size: { w: number; h: number } },
+    from: { position: { x: number; y: number }; size?: { w: number; h: number } },
+  ) {
+    const b = getBlock(id)
+    if (!b) return
+    previewResize(id, bounds.position, bounds.size)
+    try {
+      upsert(await api.resizeBlock(useWorkspaceStore().requireId(), id, bounds))
+    } catch (e) {
+      previewResize(id, from.position, from.size)
+      toast.add({
+        title: tr('board.toast.resizeFailed'),
+        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)
@@ -196,6 +257,8 @@ export function createBoardPlacement(ctx: BoardWriteContext) {
     reparentBlock,
     previewMove,
     moveBlock,
+    previewResize,
+    resizeBlock,
     updateBlock,
     toggleDependency,
     removeDependency,

package/app/stores/board.spec.ts CHANGED Viewed

@@ -310,6 +310,57 @@ describe('board store optimistic rollback', () => {
     expect(store.getBlock('t1')?.description).toBe('keep')
   })
+  it('previewResize translates the children when the drag moves the content origin', () => {
+    // A child's position is relative to its container's content origin, so growing the frame
+    // 40px west (origin -40) has to move every direct child +40 or the whole content slides with
+    // the border. A grandchild rides its module and must NOT move on its own.
+    const store = useBoardStore()
+    store.hydrate([
+      frame('f1', { position: { x: 100, y: 100 }, size: { w: 600, h: 400 } }),
+      moduleBlock('m1', 'f1', { position: { x: 20, y: 30 } }),
+      task('t1', 'f1', { position: { x: 10, y: 20 } }),
+      task('t2', 'm1', { position: { x: 5, y: 5 } }),
+    ])
+    store.previewResize('f1', { x: 60, y: 100 }, { w: 640, h: 400 })
+    expect(store.getBlock('t1')?.position).toEqual({ x: 50, y: 20 })
+    expect(store.getBlock('m1')?.position).toEqual({ x: 60, y: 30 })
+    expect(store.getBlock('t2')?.position).toEqual({ x: 5, y: 5 })
+  })
+  it('previewResize leaves the children alone when only the far border moved', () => {
+    const store = useBoardStore()
+    store.hydrate([
+      frame('f1', { position: { x: 100, y: 100 }, size: { w: 600, h: 400 } }),
+      task('t1', 'f1', { position: { x: 10, y: 20 } }),
+    ])
+    store.previewResize('f1', { x: 100, y: 100 }, { w: 700, h: 500 })
+    expect(store.getBlock('t1')?.position).toEqual({ x: 10, y: 20 })
+    expect(store.getBlock('f1')?.size).toEqual({ w: 700, h: 500 })
+  })
+  it('resizeBlock rolls the bounds AND the child translation back when the API rejects', async () => {
+    // The rollback has to undo both halves: a restored box with its contents still offset is the
+    // one failure mode that looks fine until the next refresh moves everything.
+    vi.stubGlobal('useApi', () => ({
+      resizeBlock: () => Promise.reject(new Error('conflict')),
+    }))
+    setActivePinia(createPinia())
+    useWorkspaceStore().workspaceId = 'ws1'
+    const store = useBoardStore()
+    store.hydrate([
+      frame('f1', { position: { x: 100, y: 100 }, size: { w: 600, h: 400 } }),
+      task('t1', 'f1', { position: { x: 10, y: 20 } }),
+    ])
+    await store.resizeBlock(
+      'f1',
+      { position: { x: 60, y: 70 }, size: { w: 640, h: 430 } },
+      { position: { x: 100, y: 100 }, size: { w: 600, h: 400 } },
+    )
+    expect(store.getBlock('f1')?.position).toEqual({ x: 100, y: 100 })
+    expect(store.getBlock('f1')?.size).toEqual({ w: 600, h: 400 })
+    expect(store.getBlock('t1')?.position).toEqual({ x: 10, y: 20 })
+  })
   it('reparentBlock offers an undo that moves the block back to its previous home', async () => {
     vi.stubGlobal('useApi', () => ({
       reparentBlock: async (

package/app/types/requirements.ts CHANGED Viewed

@@ -15,6 +15,7 @@ export type {
   RequirementReviewItem,
   RequirementReviewStatus,
   ResolveRequirementsExceededChoice,
+  RecommendationSource,
   RecommendationStatus,
   RequirementRecommendation,
   RequirementReview,

package/app/utils/pipeline.spec.ts CHANGED Viewed

@@ -1,8 +1,13 @@
 import { describe, expect, it } from 'vitest'
-import { pipelineAllowedForTaskType, purposeAllowsAgentCategory } from '@cat-factory/contracts'
+import {
+  pipelineAllowedForBlockLevel,
+  pipelineAllowedForTaskType,
+  purposeAllowsAgentCategory,
+} from '@cat-factory/contracts'
 import type { Block, Pipeline } from '~/types/domain'
 import {
   pipelineAllowedForManualStart,
+  pipelineAllowedForSchedule,
   pipelineDisplaySteps,
   pipelineGateCount,
 } from '~/utils/pipeline'
@@ -65,13 +70,67 @@ describe('pipelineAllowedForTaskType', () => {
     expect(pipelineAllowedForTaskType(pipeline({ purpose: undefined }), 'review')).toBe(false)
   })
-  it('every other task type is unrestricted (any purpose, and undefined type)', () => {
-    for (const type of ['feature', 'bug', 'spike', 'ralph', undefined] as const) {
+  it('a programmatic task (feature / bug) hides only what cannot ship code', () => {
+    // These ship code, so a doc-authoring or PR-review preset is meaningless for them — the mirror
+    // of the narrowing document/review tasks already had. `research` stays because reaching for a
+    // spike before committing to an approach is legitimate on an unscoped feature.
+    for (const type of ['feature', 'bug'] as const) {
       expect(pipelineAllowedForTaskType(pipeline({ purpose: 'build' }), type)).toBe(true)
-      expect(pipelineAllowedForTaskType(pipeline({ purpose: 'document' }), type)).toBe(true)
-      expect(pipelineAllowedForTaskType(pipeline({ purpose: 'review' }), type)).toBe(true)
+      expect(pipelineAllowedForTaskType(pipeline({ purpose: 'research' }), type)).toBe(true)
+      expect(pipelineAllowedForTaskType(pipeline({ purpose: 'document' }), type)).toBe(false)
+      expect(pipelineAllowedForTaskType(pipeline({ purpose: 'review' }), type)).toBe(false)
+      expect(pipelineAllowedForTaskType(pipeline({ purpose: 'planning' }), type)).toBe(false)
+    }
+  })
+  it('keeps an UNCLASSIFIED pipeline on a feature / bug task', () => {
+    // The one place this narrowing runs opposite to the document/review one, and it has to: a
+    // `purpose` is optional at every write boundary (the builder leaves it unset by default, a
+    // registered deployment pipeline need not declare one), so requiring it here would hide a
+    // workspace's own hand-built pipelines from the picker they were built for — silently, with
+    // nothing on screen to explain the absence. Unclassified is not known-wrong for a feature the
+    // way a document preset is.
+    for (const type of ['feature', 'bug'] as const) {
       expect(pipelineAllowedForTaskType(pipeline({ purpose: undefined }), type)).toBe(true)
     }
+    // Still hidden from the types whose narrowing DOES demand the explicit classifier.
+    expect(pipelineAllowedForTaskType(pipeline({ purpose: undefined }), 'document')).toBe(false)
+    expect(pipelineAllowedForTaskType(pipeline({ purpose: undefined }), 'review')).toBe(false)
+  })
+  it('an un-narrowed task type stays unrestricted (spike, ralph, custom, undefined)', () => {
+    // A custom (namespaced) deployment type has no purpose mapping we could infer, and `spike` /
+    // `ralph` pin their own default pipeline instead of narrowing the picker.
+    for (const type of ['spike', 'ralph', 'acme:incident', undefined] as const) {
+      for (const purpose of ['build', 'document', 'review', 'research', undefined] as const) {
+        expect(pipelineAllowedForTaskType(pipeline({ purpose }), type)).toBe(true)
+      }
+    }
+  })
+})
+describe('pipelineAllowedForBlockLevel (initiative binding)', () => {
+  it('offers an initiative block only planning pipelines', () => {
+    expect(pipelineAllowedForBlockLevel(pipeline({ purpose: 'planning' }), 'initiative')).toBe(true)
+    for (const purpose of ['build', 'document', 'review', 'research', undefined] as const) {
+      expect(pipelineAllowedForBlockLevel(pipeline({ purpose }), 'initiative')).toBe(false)
+    }
+  })
+  it('hides planning pipelines from every ordinary block level', () => {
+    // The surface half of the engine's BIDIRECTIONAL guard. Without it the planning presets were
+    // offered on ordinary tasks and then refused at start with a 409 — the user having already
+    // chosen before learning it could not run.
+    for (const level of ['task', 'frame', 'module', 'epic'] as const) {
+      expect(pipelineAllowedForBlockLevel(pipeline({ purpose: 'planning' }), level)).toBe(false)
+      expect(pipelineAllowedForBlockLevel(pipeline({ purpose: 'build' }), level)).toBe(true)
+    }
+  })
+  it('is unrestricted when the level is unknown', () => {
+    for (const purpose of ['build', 'planning', undefined] as const) {
+      expect(pipelineAllowedForBlockLevel(pipeline({ purpose }), undefined)).toBe(true)
+    }
   })
 })
@@ -118,3 +177,24 @@ describe('pipelineAllowedForManualStart composes the task-type gate', () => {
     expect(pipelineAllowedForManualStart(recurring, noFrame, blocks, 'document')).toBe(false)
   })
 })
+describe('pipelineAllowedForSchedule', () => {
+  const noFrame = undefined
+  const blocks: Block[] = []
+  it('keeps an ordinary build pipeline and drops a one-off-only one', () => {
+    expect(pipelineAllowedForSchedule(pipeline({ purpose: 'build' }), noFrame, blocks)).toBe(true)
+    const oneOff = pipeline({ purpose: 'build', availability: 'one-off' })
+    expect(pipelineAllowedForSchedule(oneOff, noFrame, blocks)).toBe(false)
+  })
+  it('drops the planning presets, which nothing else keeps out of this picker', () => {
+    // A schedule seeds a `level: 'task'` block on every fire, so the engine refuses a planning
+    // pipeline exactly as it would on a manual start — and the planning presets carry no
+    // `availability`, so the one-off filter above never touched them. Worse than the manual case
+    // because a schedule fires unattended: nobody sees the refusal, the work just stops happening.
+    expect(pipelineAllowedForSchedule(pipeline({ purpose: 'planning' }), noFrame, blocks)).toBe(
+      false,
+    )
+  })
+})

package/app/utils/pipeline.ts CHANGED Viewed

@@ -1,9 +1,10 @@
 import {
   frameAllowsVisualPipeline,
+  pipelineAllowedForBlockLevel,
   pipelineAllowedForTaskType,
   pipelineHasVisualStep,
 } from '@cat-factory/contracts'
-import type { AgentKind, Block, Pipeline } from '~/types/domain'
+import type { AgentKind, Block, BlockLevel, Pipeline } from '~/types/domain'
 /** One agent step of a pipeline as shown in a preview: its kind + whether it's a human-gated step. */
 export interface PipelineDisplayStep {
@@ -38,9 +39,9 @@ export function pipelineGateCount(pipeline: Pipeline): number {
   return pipelineDisplaySteps(pipeline).filter((s) => s.gated).length
 }
-// Re-exported so a picker can import the task-type gate from the same module as the
-// launch/frame gates it composes with (the classifier itself lives in `@cat-factory/contracts`).
-export { pipelineAllowedForTaskType }
+// Re-exported so a picker can import the purpose gates from the same module as the launch/frame
+// gates they compose with (the classifiers themselves live in `@cat-factory/contracts`).
+export { pipelineAllowedForBlockLevel, pipelineAllowedForTaskType }
 // Surface counterpart to the backend's slice-4c run-start gate: a pipeline with a visual step
 // (`tester-ui` / `visual-confirmation`) may run only on a frame with a UI to exercise — a
@@ -69,32 +70,52 @@ export function pipelineAllowedForFrame(
 /**
  * Whether `pipeline` may be started as a MANUAL one-off task run (the board/inspector Run menus,
- * the add-task modal, the task run-settings default). Excludes `'recurring'`-only pipelines the
- * backend would refuse, visual pipelines on a frame with no UI, and — when a `taskType` is given —
- * pipelines whose `purpose` doesn't fit that task type (a `document` task offers only document
- * pipelines). `taskType` omitted ⇒ no task-type restriction (an un-typed context shows all).
+ * the add-task modal, the task run-settings default). Excludes, in turn:
+ *
+ *  - `'recurring'`-only pipelines the backend would refuse;
+ *  - visual pipelines on a frame with no UI;
+ *  - pipelines whose `purpose` doesn't fit the given `taskType` (a `document` task offers only
+ *    document pipelines; a `feature`/`bug` task only build + research ones);
+ *  - pipelines whose `purpose` doesn't fit the given `blockLevel` (planning pipelines run only on
+ *    an initiative block, and an initiative block runs only those).
+ *
+ * `taskType` / `blockLevel` omitted ⇒ that restriction is not applied, so an un-typed context still
+ * shows everything.
  */
 export function pipelineAllowedForManualStart(
   pipeline: Pipeline,
   frame: Block | undefined,
   blocks: readonly Block[],
   taskType?: Block['taskType'],
+  blockLevel?: BlockLevel,
 ): boolean {
   return (
     pipeline.availability !== 'recurring' &&
     pipelineAllowedForFrame(pipeline, frame, blocks) &&
-    pipelineAllowedForTaskType(pipeline, taskType)
+    pipelineAllowedForTaskType(pipeline, taskType) &&
+    pipelineAllowedForBlockLevel(pipeline, blockLevel)
   )
 }
 /**
  * Whether `pipeline` may be attached to a RECURRING schedule (the recurring-pipeline modal).
- * Excludes `'one-off'`-only pipelines the backend would refuse.
+ * Excludes `'one-off'`-only pipelines the backend would refuse, visual pipelines on a frame with no
+ * UI, and the planning presets.
+ *
+ * The block-level gate applies here for the same reason it applies to a manual start, and it is
+ * keyed to `'task'` because a schedule seeds a `level: 'task'` block under its frame on every fire
+ * (`RecurringPipelineService`). The planning presets carry no `availability`, so nothing else keeps
+ * them out of this picker — and a schedule the engine refuses is WORSE than a manual start it
+ * refuses: it fires unattended, so nobody sees the error and the work simply never happens.
  */
 export function pipelineAllowedForSchedule(
   pipeline: Pipeline,
   frame: Block | undefined,
   blocks: readonly Block[],
 ): boolean {
-  return pipeline.availability !== 'one-off' && pipelineAllowedForFrame(pipeline, frame, blocks)
+  return (
+    pipeline.availability !== 'one-off' &&
+    pipelineAllowedForFrame(pipeline, frame, blocks) &&
+    pipelineAllowedForBlockLevel(pipeline, 'task')
+  )
 }

package/i18n/locales/de.json CHANGED Viewed

@@ -2313,6 +2313,7 @@
       "updateFailed": "Änderungen konnten nicht gespeichert werden",
       "epicFailed": "Epic konnte nicht geändert werden",
       "moveFailed": "Verschieben nicht möglich",
+      "resizeFailed": "Größe konnte nicht geändert werden",
       "deleteFailed": "Löschen nicht möglich",
       "linkFailed": "Aufgaben konnten nicht verknüpft werden",
       "unlinkFailed": "Abhängigkeit konnte nicht entfernt werden",
@@ -2566,7 +2567,6 @@
       "mergedOfTotal": "{merged}/{total} gemergt",
       "noTasksYet": "Noch keine Aufgaben",
       "prCount": "{count} PR",
-      "implemented": "{merged}/{total} implementiert",
       "prReadyCount": "{count} PR bereit",
       "taskCount": "{count} Aufgabe | {count} Aufgaben",
       "moduleCount": "{count} Modul | {count} Module",
@@ -3864,6 +3864,12 @@
     "recommendationProgress": "{ready} / {total} bereit",
     "generatingSuggestion": "Ein fundierter Vorschlag wird generiert…",
     "currentStandard": "Aktueller Standard: {title}",
+    "grounding": {
+      "standard": "Team-Standard",
+      "project-spec": "Projektspezifikation",
+      "web": "Webquelle",
+      "general-practice": "Allgemeine Praxis"
+    },
     "accept": "Annehmen",
     "reject": "Ablehnen",
     "reRequestPlaceholder": "Nach einer anderen Empfehlung fragen…",