@cat-factory/app 0.192.0 → 0.193.0

package/app/components/board/AddTaskModal.vue

@@ -387,13 +387,15 @@ const fragmentPool = computed(() => fragments.forBlockType(frame.value?.type ??
 
 // Hide UI-testing pipelines (`tester-ui` / `visual-confirmation`) when the target frame has no
 // UI to exercise — they'd be refused server-side (see utils/pipeline + the backend gate). Also
-// hide `'recurring'`-only pipelines (a one-off task start of one is refused at run start) and,
-// for a `document` / `review` task, every pipeline whose purpose doesn't match (a doc task authors
-// a doc, a review task reviews a PR — only document / review pipelines are relevant, per the
-// `purpose` classifier). Re-filters as the chosen task type changes.
+// hide `'recurring'`-only pipelines (a one-off task start of one is refused at run start) and every
+// pipeline whose purpose doesn't match the chosen task type (a doc task authors a doc, a review task
+// reviews a PR, and a `feature`/`bug` task ships code — so it is offered build + research only, not
+// the doc/review/planning presets). `blockLevel: 'task'` is passed literally because this modal only
+// ever creates a task leaf, which also drops the three planning presets the backend would refuse.
+// Re-filters as the chosen task type changes.
 const selectablePipelines = computed(() =>
   pipelines.pipelines.filter((p) =>
-    pipelineAllowedForManualStart(p, frame.value, board.blocks, taskType.value),
+    pipelineAllowedForManualStart(p, frame.value, board.blocks, taskType.value, 'task'),
   ),
 )
 // Some task types want their type-default pipeline surfaced in the modal up front, so picking the

package/app/components/board/RecurringPipelineModal.vue

@@ -74,9 +74,15 @@ const selectedPipeline = computed(() => pipelines.getPipeline(pipelineId.value))
 
 // Infer the template from the picked pipeline so the backend seeds the right block
 // description (and so we know to show the tracker config).
+//
+// Only the pipelines whose SHAPE is specific to one kind of recurring work can be inferred this
+// way. `dep-update` no longer can: its pipeline was retired in the catalog collapse (it was the
+// ordinary build tail under a recurring name), so a dependency-update schedule now runs an ordinary
+// build rung — which is also what every generic schedule runs, so inferring the template from it
+// would mislabel all of them. The template itself survives for an explicit API caller; see
+// `scheduleTemplateSchema`.
 const template = computed<ScheduleTemplate>(() => {
   if (pipelineId.value === 'pl_tech_debt') return 'tech-debt'
-  if (pipelineId.value === 'pl_dep_update') return 'dep-update'
   if (pipelineId.value === 'pl_bug_triage') return 'bug-triage'
   return 'custom'
 })
@@ -99,11 +105,10 @@ watch(open, (isOpen) => {
   if (!isOpen) return
   name.value = ''
   description.value = ''
-  // Default to the Dependency-updates pipeline if present, else the first.
-  pipelineId.value =
-    pipelines.pipelines.find((p) => p.id === 'pl_dep_update')?.id ??
-    pipelines.pipelines[0]?.id ??
-    ''
+  // Default to the first schedulable pipeline, which is the ladder's own default rung. There is no
+  // longer a canned recurring build preset to prefer — the dependency-update pipeline was the
+  // ordinary build tail under another name — so the default build is the honest starting point.
+  pipelineId.value = selectablePipelines.value[0]?.id ?? pipelines.pipelines[0]?.id ?? ''
   recurrence.value = defaultRecurrence()
   onDemand.value = false
   saving.value = false

package/app/components/focus/BlockFocusView.vue

@@ -30,12 +30,20 @@ const deps = computed(() =>
 )
 
 // Hide UI-testing pipelines when this block's frame has no UI to exercise, `'recurring'`-only
-// pipelines (a manual run of one is refused server-side), and — for a `document` task — every
-// non-document pipeline (per the `purpose` classifier) — see the backend gate.
+// pipelines (a manual run of one is refused server-side), and every pipeline whose purpose doesn't
+// match this block's task type or LEVEL (per the `purpose` classifier) — see the backend gate. The
+// level is what keeps the planning presets on initiative blocks and off everything else, in both
+// directions, so this menu never offers a run the engine answers with a 409.
 const runOptions = computed(() => {
   const frame = block.value ? board.serviceOf(block.value) : undefined
   return pipelines.pipelines.filter((p) =>
-    pipelineAllowedForManualStart(p, frame, board.blocks, block.value?.taskType),
+    pipelineAllowedForManualStart(
+      p,
+      frame,
+      board.blocks,
+      block.value?.taskType,
+      block.value?.level,
+    ),
   )
 })
 

package/app/components/panels/InspectorPanel.vue

@@ -178,13 +178,24 @@ const taskBranchUrl = computed(() => {
   return base ? `${base}/tree/${pr.branch}` : null
 })
 
-// Hide UI-testing pipelines when this block's frame has no UI to exercise, and `'recurring'`-only
-// pipelines (a manual run of one is refused server-side) — they'd be refused at run start (see
-// utils/pipeline + the backend gate).
+// Hide UI-testing pipelines when this block's frame has no UI to exercise, `'recurring'`-only
+// pipelines (a manual run of one is refused server-side), and every pipeline whose purpose doesn't
+// match this block's task type or LEVEL — they'd be refused at run start (see utils/pipeline + the
+// backend gate). The level is what keeps the planning presets on initiative blocks and off
+// everything else, so this menu never offers a run the engine answers with a 409; it applies to
+// frames and modules too, which is why it reads `block.level` rather than assuming a task.
 const runMenu = computed(() => {
   const frame = block.value ? board.serviceOf(block.value) : undefined
   return pipelines.pipelines
-    .filter((p) => pipelineAllowedForManualStart(p, frame, board.blocks))
+    .filter((p) =>
+      pipelineAllowedForManualStart(
+        p,
+        frame,
+        board.blocks,
+        block.value?.taskType,
+        block.value?.level,
+      ),
+    )
     .map((p) => ({
       label: p.name,
       icon: 'i-lucide-play',

package/app/components/panels/inspector/TaskRunSettings.vue

@@ -144,10 +144,14 @@ const selectedPipeline = computed(() =>
 // pipelines (the task's manual Run control can't start one), and — for a `document` task — every
 // non-document pipeline (it authors a doc, so a build/test pipeline makes no sense). All would be
 // refused / wrong at run start (see utils/pipeline + the backend gate + the purpose classifier).
+// `blockLevel: 'task'` is passed literally because this panel only ever edits a task leaf, which
+// drops the planning presets the engine would refuse. The task-type narrowing already excludes them
+// for `feature`/`bug`, but NOT for a `spike` / `ralph` / deployment-custom type — and a planning
+// preset settable as a task's DEFAULT pipeline is a 409 on every later Start.
 const taskFrame = computed(() => board.serviceOf(props.block))
 const selectablePipelines = computed(() =>
   pipelines.pipelines.filter((p) =>
-    pipelineAllowedForManualStart(p, taskFrame.value, board.blocks, props.block.taskType),
+    pipelineAllowedForManualStart(p, taskFrame.value, board.blocks, props.block.taskType, 'task'),
   ),
 )
 function setPipeline(id: string) {

package/app/composables/usePipelineHealth.spec.ts

@@ -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

@@ -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/utils/pipeline.spec.ts

@@ -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

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.192.0",
+  "version": "0.193.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.199.0"
+    "@cat-factory/contracts": "0.200.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",