@cat-factory/app 0.257.0 → 0.258.0

package/app/components/pipeline/PipelinePreview.vue

@@ -11,7 +11,12 @@
 import { computed } from 'vue'
 import type { Pipeline } from '~/types/domain'
 import { agentKindMeta } from '~/utils/catalog'
-import { pipelineDisplaySteps, pipelineGateCount } from '~/utils/pipeline'
+import {
+  CONDITION_MARKERS,
+  pipelineConditionalCount,
+  pipelineDisplaySteps,
+  pipelineGateCount,
+} from '~/utils/pipeline'
 import AgentKindIcon from '~/components/pipeline/AgentKindIcon.vue'
 
 const props = defineProps<{ pipeline: Pipeline }>()
@@ -19,6 +24,7 @@ const { t } = useI18n()
 
 const steps = computed(() => pipelineDisplaySteps(props.pipeline))
 const gateCount = computed(() => pipelineGateCount(props.pipeline))
+const conditionalCount = computed(() => pipelineConditionalCount(props.pipeline))
 
 /** What the agent at this step does — the same catalog prose the palette and step tooltips use. */
 function stepDescription(kind: string): string {
@@ -50,6 +56,12 @@ function stepDescription(kind: string): string {
         <UIcon name="i-lucide-shield-check" class="h-3 w-3" />
         {{ t('pipeline.preview.gateCount', { count: gateCount }, gateCount) }}
       </span>
+      <!-- Conditional steps change what a run of this pipeline actually does from task to task,
+           which is exactly what a preview read BEFORE picking has to say out loud. -->
+      <span v-if="conditionalCount" class="inline-flex items-center gap-1 text-sky-500">
+        <UIcon name="i-lucide-git-branch" class="h-3 w-3" />
+        {{ t('pipeline.preview.conditionalCount', { count: conditionalCount }, conditionalCount) }}
+      </span>
     </div>
 
     <!-- The ordered steps. The number column doubles as the flow connector (a rule drawn between
@@ -79,6 +91,13 @@ function stepDescription(kind: string): string {
               class="h-3 w-3 shrink-0 text-amber-400"
               :title="t('pipeline.preview.gated')"
             />
+            <UIcon
+              v-for="c in s.conditions"
+              :key="c"
+              :name="CONDITION_MARKERS[c].icon"
+              class="h-3 w-3 shrink-0 text-sky-400"
+              :title="t(CONDITION_MARKERS[c].key)"
+            />
           </div>
           <!-- Clamped: the catalog prose runs long for some kinds, and <AgentKindIcon> already
                carries the full text in its hover tooltip. -->

package/app/components/pipeline/PipelineProgress.vue

@@ -12,6 +12,7 @@ import {
   containerPhaseLabel,
   dedicatedParkView,
   REDIRECT_PARK_PRESENTATION,
+  stepSkipReasonKey,
 } from '~/utils/pipelineRender'
 import { prReviewPhase } from '~/utils/prReviewProgress'
 import StepMetricsBar from '~/components/observability/StepMetricsBar.vue'
@@ -559,6 +560,18 @@ const ITEM_ICON: Record<string, string> = {
             {{ t('pipeline.progress.clickToRead') }}
           </p>
 
+          <!-- Why a skipped step did not run. A skipped step finishes `done` with no output, so
+               without this line it is indistinguishable from one that ran and said nothing —
+               which reads as a tester that silently did its job. -->
+          <p
+            v-if="stepSkipReasonKey(s)"
+            class="mt-2 flex items-center gap-1 text-[11px] text-slate-500"
+            data-testid="step-skip-reason"
+          >
+            <UIcon name="i-lucide-skip-forward" class="h-3 w-3 shrink-0" />
+            {{ t(stepSkipReasonKey(s)!) }}
+          </p>
+
           <!-- Conditionally-run companion (today the Tester's fixer): a distinct
                sub-node marked possible / running / completed / skipped. -->
           <div

package/app/composables/api/execution.ts

@@ -15,6 +15,7 @@ import {
   resolveStepExceededContract,
   restartExecutionContract,
   resumeSpendContract,
+  startAgentKindExecutionContract,
   startExecutionContract,
 } from '@cat-factory/contracts'
 import type { RequestStepChangesInput, RunMode } from '@cat-factory/contracts'
@@ -41,6 +42,24 @@ export function executionApi({ send, sendWith, ws, pwHeaders }: ApiContext) {
         body,
       }),
 
+    /**
+     * Start ONE agent kind against a block — a run with no pipeline behind it (the service
+     * frame's "Map service" action, the environment wizard's deep analysis). Gated on the
+     * personal password exactly as a pipeline start is: the kind leases a personal subscription
+     * the same way a pipeline step does.
+     */
+    startAgentKindExecution: (
+      workspaceId: string,
+      blockId: string,
+      agentKind: string,
+      password?: string,
+    ) =>
+      sendWith(pwHeaders(password), startAgentKindExecutionContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
+        body: { agentKind },
+      }),
+
     cancelExecution: (workspaceId: string, blockId: string) =>
       send(cancelExecutionContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
 

package/app/composables/usePipelineHealth.spec.ts

@@ -7,7 +7,7 @@ import { usePipelineHealth } from '~/composables/usePipelineHealth'
 /**
  * Guards the startup pipeline-health advisory against the failure that bit the first cut: a
  * legitimate built-in agent kind missing from the frontend catalog made `isKnownAgentKind`
- * return false, so a stock seeded pipeline (`pl_tech_debt`, which uses `analysis` + `tracker`)
+ * return false, so a stock seeded pipeline (one using `analysis` + `tracker`)
  * was reported "invalid" in every workspace with a Reseed action that could never fix it.
  *
  * The kind lists below mirror the canonical built-ins in
@@ -94,8 +94,8 @@ describe('isKnownAgentKind', () => {
 })
 
 describe('usePipelineHealth', () => {
-  it('does not flag the stock tech-debt built-in (analysis + tracker) as invalid', () => {
-    const techDebt = builtin(
+  it('does not flag an audit pipeline (analysis + tracker) as invalid', () => {
+    const audit = builtin(
       [
         'analysis',
         'tracker',
@@ -107,9 +107,9 @@ describe('usePipelineHealth', () => {
         'ci',
         'merger',
       ],
-      { id: 'pl_tech_debt', name: 'Tech debt' },
+      { id: 'pl_audit', name: 'Audit and fix' },
     )
-    const { hasIssues, invalid, outdated } = scan([techDebt])
+    const { hasIssues, invalid, outdated } = scan([audit])
     expect(hasIssues.value).toBe(false)
     expect(invalid.value).toHaveLength(0)
     expect(outdated.value).toHaveLength(0)
@@ -164,6 +164,43 @@ describe('usePipelineHealth', () => {
     expect(invalid.value[0]!.problems.some((p) => p.type === 'shape')).toBe(true)
   })
 
+  // The RUN CONDITION is the second skip axis, and the advisory has to mirror it for the same
+  // reason it mirrors the estimate gate: a rule the engine enforces at save that this scan calls
+  // healthy leaves the author to discover it as a 422.
+  it('accepts a run condition on a kind the shared gatable set allows', () => {
+    const conditional = builtin(['coder', 'reviewer', 'tester-ui'], {
+      stepOptions: [null, null, { condition: { serviceScope: 'frontend' } }],
+    })
+    expect(scan([conditional]).hasIssues.value).toBe(false)
+  })
+
+  it('flags a run condition on a kind the run structurally needs (merger)', () => {
+    const conditionalMerger = builtin(['coder', 'merger'], {
+      stepOptions: [null, { condition: { serviceScope: 'frontend' } }],
+    })
+    const { invalid } = scan([conditionalMerger])
+    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 a run condition (shape)', () => {
+    const both = builtin(['coder', 'tester-ui'], {
+      gates: [false, true],
+      stepOptions: [null, { condition: { serviceScope: 'frontend' } }],
+    })
+    const { invalid } = scan([both])
+    expect(invalid.value).toHaveLength(1)
+    expect(invalid.value[0]!.problems.some((p) => p.type === 'shape')).toBe(true)
+  })
+
+  it('accepts a run condition BESIDE an estimate gate: the axes compose', () => {
+    const both = builtin(['task-estimator', 'coder', 'tester-ui'], {
+      gating: [null, null, { enabled: true, minComplexity: 0.4, onMissingEstimate: 'run' }],
+      stepOptions: [null, null, { condition: { serviceScope: 'frontend' } }],
+    })
+    expect(scan([both]).hasIssues.value).toBe(false)
+  })
+
   it('flags a step carrying BOTH a human approval gate and an estimate gate (shape)', () => {
     const both = builtin(['task-estimator', 'architect'], {
       gates: [false, true],

package/app/composables/usePipelineHealth.ts

@@ -80,24 +80,11 @@ function companionTargets(companion: string): string[] {
 const isEnabledAt = (p: Pipeline, i: number) => p.enabled?.[i] !== false
 
 /**
- * Client-side mirror of the backend `validatePipelineShape` (companion adjacency + estimate
- * 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.
+ * Companion adjacency: an enabled companion's nearest preceding ENABLED step must be a producer it
+ * can review. Mirrors `assertValidCompanionPlacement`.
  */
-function shapeProblem(p: Pipeline): string | null {
+function companionProblem(p: Pipeline): string | null {
   const kinds = p.agentKinds
-  // No enabled steps ⇒ nothing would run.
-  if (kinds.length === 0 || !kinds.some((_, i) => isEnabledAt(p, i))) {
-    return 'No enabled steps — the pipeline has nothing to run.'
-  }
-  // Companion adjacency: an enabled companion's nearest preceding enabled step must be a
-  // producer it can review.
   for (let i = 0; i < kinds.length; i++) {
     const kind = kinds[i]
     if (!kind || !isProducerCompanion(kind) || !isEnabledAt(p, i)) continue
@@ -113,44 +100,118 @@ 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 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.
+  return null
+}
+
+/**
+ * The rule both SKIP AXES share: a step that may be absent from a run must be a kind whose result
+ * later steps read as context, and must not also carry a human approval gate (a skip may leave a
+ * checkpoint un-reached, never cancel one the author asked for). Returns the problem, or null.
+ *
+ * Shared by {@link gatingProblem} and {@link conditionProblem} rather than written twice, because
+ * the reason is identical and only the axis's name differs — which is exactly how the two would
+ * drift apart. `axis` supplies the naming, mirroring `assertValidGating` /
+ * `assertValidRunConditions`.
+ *
+ * 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.
+ */
+function skipAxisProblem(
+  p: Pipeline,
+  i: number,
+  axis: {
+    notGatable: (kind: string | undefined) => string
+    withHumanGate: (kind: string) => string
+  },
+): string | null {
+  const kind = p.agentKinds[i]
+  if (!kind || !isBuiltinGatableKind(kind)) return axis.notGatable(kind)
+  if (p.gates?.[i] === true) return axis.withHumanGate(kind)
+  return null
+}
+
+/**
+ * Estimate gating: the shared skip-axis rules, plus the two specific to an estimate — at least one
+ * axis threshold (with none the step would ALWAYS skip) and an enabled task-estimator earlier in
+ * the chain (or the gate has nothing to consult). Mirrors `assertValidGating`.
+ */
+function gatingProblem(p: Pipeline): string | null {
   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 || !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).`
-      }
-      const hasEstimator = kinds
-        .slice(0, i)
-        .some((k, j) => k === TASK_ESTIMATOR_KIND && isEnabledAt(p, j))
-      if (!hasEstimator) {
-        return `Step '${kind}' is gated on the estimate but no enabled '${TASK_ESTIMATOR_KIND}' runs before it.`
-      }
+  if (!gating) return null
+  const kinds = p.agentKinds
+  for (let i = 0; i < kinds.length; i++) {
+    const g = gating[i] as StepGating | null | undefined
+    if (!g?.enabled || !isEnabledAt(p, i)) continue
+    const shared = skipAxisProblem(p, i, {
+      notGatable: (kind) =>
+        `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.`,
+      withHumanGate: (kind) =>
+        `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 (shared) return shared
+    const kind = kinds[i]
+    if (g.minComplexity === undefined && g.minRisk === undefined && g.minImpact === undefined) {
+      return `Step '${kind}' is estimate-gated but sets no threshold (complexity / risk / impact).`
+    }
+    const hasEstimator = kinds
+      .slice(0, i)
+      .some((k, j) => k === TASK_ESTIMATOR_KIND && isEnabledAt(p, j))
+    if (!hasEstimator) {
+      return `Step '${kind}' is gated on the estimate but no enabled '${TASK_ESTIMATOR_KIND}' runs before it.`
     }
   }
   return null
 }
 
+/**
+ * Run conditions: the SECOND skip axis, held to the shared rules and nothing more. A skip is a skip
+ * whichever axis caused it, so a condition on a non-gatable kind drops something the run needs.
+ * Mirrors `assertValidRunConditions`. A condition BESIDE an estimate gate is deliberately fine.
+ */
+function conditionProblem(p: Pipeline): string | null {
+  const stepOptions = p.stepOptions
+  if (!stepOptions) return null
+  for (let i = 0; i < p.agentKinds.length; i++) {
+    if (!stepOptions[i]?.condition || !isEnabledAt(p, i)) continue
+    const problem = skipAxisProblem(p, i, {
+      notGatable: (kind) =>
+        `Step '${kind}' may not carry a run condition — its output is required by the rest of the run, so a run outside the condition's scope would silently finish without it.`,
+      withHumanGate: (kind) =>
+        `Step '${kind}' carries a human approval gate, so it cannot also carry a run condition — a condition may leave a checkpoint un-reached but never remove one.`,
+    })
+    if (problem) return problem
+  }
+  return null
+}
+
+/**
+ * Client-side mirror of the backend `validatePipelineShape` (companion adjacency + both skip axes,
+ * 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`.
+ *
+ * One delegate per rule, in the order the backend checks them, so adding the next rule is a
+ * function beside these rather than another branch inside one that already carries three.
+ *
+ * A rule here must be keyed off vocabulary SHARED with that module (`@cat-factory/contracts`)
+ * wherever one exists, never re-stated locally — see {@link skipAxisProblem} for what a drifted
+ * copy costs. Adding a rule to `validatePipelineShape` 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 {
+  // No enabled steps ⇒ nothing would run.
+  if (p.agentKinds.length === 0 || !p.agentKinds.some((_, i) => isEnabledAt(p, i))) {
+    return 'No enabled steps — the pipeline has nothing to run.'
+  }
+  return companionProblem(p) ?? gatingProblem(p) ?? conditionProblem(p)
+}
+
 /**
  * Detect pipelines in an unhealthy state for the startup advisory: those referencing an unknown
  * agent kind or with an invalid shape (offer to delete a custom one / reseed a built-in), built-ins

package/app/modular/agent-kinds.ts

@@ -35,6 +35,11 @@ export function customKindToArchetype(kind: CustomAgentKind): AgentArchetype {
     // projection would fork the rule the moment the default changes.
     ...(p.tier ? { tier: p.tier } : {}),
     ...(p.resultView ? { resultView: p.resultView } : {}),
+    // The kind is the platform's to dispatch, not a block anyone places. Carried onto the
+    // archetype rather than dropped at the projection because the catalog is also the READ MODEL
+    // every run view resolves a step's label and icon through: filtering it out here would leave
+    // the wizard's own analyst run rendering as an unknown kind.
+    ...(p.internal ? { internal: true } : {}),
     // Not part of `presentation` on the wire — it is a fact about how the kind RUNS, projected
     // beside `container` — so it is lifted from the entry itself. Carried onto the archetype
     // because the pipeline builder resolves a step's meta through `agentKindMeta`, not through

package/app/stores/environmentWizard/context.ts

@@ -9,7 +9,6 @@ import type { useBoardStore } from '~/stores/board'
 import type { useExecutionStore } from '~/stores/execution'
 import type { useGitHubStore } from '~/stores/github'
 import type { useInfraConfigStore } from '~/stores/infraConfig'
-import type { usePipelinesStore } from '~/stores/pipelines'
 import type { usePreflightsStore } from '~/stores/preflights'
 
 /**
@@ -47,7 +46,6 @@ export interface WizardContext {
   trialStarted: Ref<boolean>
   // ---- derived the actions read ----
   repoContext: ComputedRef<{ githubId: number; directory?: string | null } | undefined>
-  analysisPipeline: ComputedRef<ReturnType<ReturnType<typeof usePipelinesStore>['getPipeline']>>
   merged: ComputedRef<MergedRecipeDraft | null>
 }
 

package/app/stores/environmentWizard/flow.ts

@@ -1,3 +1,4 @@
+import { ENVIRONMENT_ANALYST_AGENT_KIND } from '@cat-factory/contracts'
 import type { WizardContext } from './context'
 import { cloneRecipe } from './context'
 
@@ -34,7 +35,6 @@ export function createFlowActions(ctx: WizardContext) {
     trialError,
     trialStarted,
     repoContext,
-    analysisPipeline,
     merged,
   } = ctx
 
@@ -117,18 +117,23 @@ export function createFlowActions(ctx: WizardContext) {
     if (id) void detect()
   }
 
-  /** Fire the analyst-only pipeline against the frame (mirrors how bootstrap runs pl_blueprint). */
+  /**
+   * Run the analyst agent against the frame — a SINGLE-KIND run, the same seam the board's
+   * "Map service" action uses. `startAgentKind` reports a refusal by returning false (it has
+   * already surfaced the reason as a toast), so both halves of "it did not start" land on the
+   * wizard's own error state rather than only the thrown one.
+   */
   async function startAnalysis() {
     const id = frameId.value
-    const pipeline = analysisPipeline.value
-    if (!id || !pipeline) {
+    if (!id) {
       analysisError.value = true
       return
     }
     analysisError.value = false
     try {
-      await execution.start(id, pipeline)
-      analysisRequested.value = true
+      const started = await execution.startAgentKind(id, ENVIRONMENT_ANALYST_AGENT_KIND)
+      if (started) analysisRequested.value = true
+      else analysisError.value = true
     } catch {
       analysisError.value = true
     }

package/app/stores/environmentWizard.ts

@@ -7,6 +7,8 @@ import {
   type PreflightResult,
   type ProvisioningRecommendation,
   type StackRecipe,
+  ENVIRONMENT_ANALYST_AGENT_KIND,
+  adHocPipelineIdFor,
   analystRecipeDraftSchema,
   mergeAnalystRecipeDraft,
 } from '@cat-factory/contracts'
@@ -15,7 +17,6 @@ import { useBoardStore } from '~/stores/board'
 import { useExecutionStore } from '~/stores/execution'
 import { useGitHubStore } from '~/stores/github'
 import { useInfraConfigStore } from '~/stores/infraConfig'
-import { usePipelinesStore } from '~/stores/pipelines'
 import { usePreflightsStore } from '~/stores/preflights'
 import { useServicesStore } from '~/stores/services'
 import type { WizardContext } from '~/stores/environmentWizard/context'
@@ -43,10 +44,11 @@ import { createSaveActions } from '~/stores/environmentWizard/save'
 // recipe / save) that close over the shared reactive {@link WizardContext} assembled here — a
 // size-only extraction following the `board` store idiom, behaviour is unchanged.
 
-/** The seeded analyst-only pipeline the "run deep analysis" trigger starts against the frame. */
-const ANALYSIS_PIPELINE_ID = 'pl_environment_analysis'
-/** The analyst agent kind whose `result.custom` carries the drafted recipe. */
-const ANALYST_AGENT_KIND = 'environment-analyst'
+// The "run deep analysis" trigger starts the analyst agent as a SINGLE-KIND run — one step, no
+// pipeline — and reads the drafted recipe off that step's `result.custom`. Both the kind and the
+// id its run reports come from the shared contract, so the wizard cannot go looking for a run
+// under a name the backend stopped using.
+const ANALYSIS_PIPELINE_ID = adHocPipelineIdFor(ENVIRONMENT_ANALYST_AGENT_KIND)
 
 /** The analyst run's lifecycle as the wizard surfaces it. */
 export type AnalysisStatus = 'idle' | 'running' | 'ready' | 'failed'
@@ -57,7 +59,6 @@ export const useEnvironmentWizardStore = defineStore('environmentWizard', () =>
   const services = useServicesStore()
   const infra = useInfraConfigStore()
   const execution = useExecutionStore()
-  const pipelines = usePipelinesStore()
   const preflights = usePreflightsStore()
 
   // ---- Target frame -------------------------------------------------------
@@ -124,9 +125,10 @@ export const useEnvironmentWizardStore = defineStore('environmentWizard', () =>
 
   const hasRepo = computed(() => repoContext.value !== undefined)
 
-  /** The seeded analyst pipeline, when present in the workspace (else deep analysis is unavailable). */
-  const analysisPipeline = computed(() => pipelines.getPipeline(ANALYSIS_PIPELINE_ID))
-  const canAnalyze = computed(() => hasRepo.value && analysisPipeline.value !== undefined)
+  // Deep analysis needs only a repo to read: the agent is started by KIND, so there is no
+  // catalog row for the workspace to be missing (which is what the old `pl_environment_analysis`
+  // lookup guarded against).
+  const canAnalyze = computed(() => hasRepo.value)
 
   /** The analyst run for this frame (newest matching instance), read live from the execution store.
    *  Filters the full instance list (not the collapsing `getByBlock`, which returns a single run per
@@ -153,7 +155,7 @@ export const useEnvironmentWizardStore = defineStore('environmentWizard', () =>
   const analystDraft = computed<AnalystRecipeDraft | null>(() => {
     const run = analystRun.value
     if (!run) return null
-    const analystStep = run.steps.find((s) => s.agentKind === ANALYST_AGENT_KIND)
+    const analystStep = run.steps.find((s) => s.agentKind === ENVIRONMENT_ANALYST_AGENT_KIND)
     if (!analystStep || analystStep.state !== 'done' || analystStep.custom === undefined)
       return null
     const parsed = v.safeParse(analystRecipeDraftSchema, analystStep.custom)
@@ -207,7 +209,6 @@ export const useEnvironmentWizardStore = defineStore('environmentWizard', () =>
     trialError,
     trialStarted,
     repoContext,
-    analysisPipeline,
     merged,
   }
   const flow = createFlowActions(context)

package/app/stores/execution/commands.ts

@@ -41,10 +41,15 @@ export function createExecutionCommands(ctx: ExecutionCommandContext) {
    * and nothing merges. It is a request, not a decision — the task's merge preset can sandbox a
    * role's runs whatever they asked for, so what the run got is read back off the run's own
    * `mode`, never assumed from what was sent here.
+   *
+   * Takes the id + name it actually sends and reports, not a whole {@link Pipeline}: a caller may
+   * legitimately hold neither, because a task can be pinned to an INTERNAL pipeline that the
+   * library withholds from every picker. Demanding the row there would force the caller to either
+   * fabricate one or silently start something else.
    */
   async function start(
     blockId: string,
-    pipeline: Pipeline,
+    pipeline: Pick<Pipeline, 'id' | 'name'>,
     options?: { mode?: RunMode },
   ): Promise<boolean> {
     const ws = useWorkspaceStore()
@@ -71,6 +76,25 @@ export function createExecutionCommands(ctx: ExecutionCommandContext) {
     }
   }
 
+  /**
+   * Start ONE agent kind against a block. The single-kind counterpart of {@link start}: same
+   * credential gate, same snapshot refresh, same false-on-refusal contract — only the thing being
+   * started is an agent rather than a pipeline.
+   */
+  async function startAgentKind(blockId: string, agentKind: string): Promise<boolean> {
+    const ws = useWorkspaceStore()
+    const personal = usePersonalSubscriptionsStore()
+    try {
+      return await personal.withCredential(async (password) => {
+        await api.startAgentKindExecution(ws.requireId(), blockId, agentKind, 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
@@ -237,6 +261,7 @@ export function createExecutionCommands(ctx: ExecutionCommandContext) {
 
   return {
     start,
+    startAgentKind,
     resolveDecision,
     approveStep,
     requestStepChanges,

package/app/stores/pipelines/draftActions.ts

@@ -4,6 +4,7 @@ import { companionForProducer } from '~/utils/catalog'
 import type { PipelinesContext } from './context'
 import { createPipelineGateConfigActions } from './draftGateConfig'
 import { createPipelineStepConfigActions } from './draftStepConfig'
+import { createPipelineStepOptionActions } from './draftStepOptions'
 
 /**
  * The pipeline-builder draft's STRUCTURE: inserting/removing/reordering steps, the companion
@@ -193,6 +194,7 @@ export function createPipelineDraftActions(ctx: PipelinesContext) {
 
   return {
     ...createPipelineStepConfigActions(ctx),
+    ...createPipelineStepOptionActions(ctx),
     ...createPipelineGateConfigActions(ctx),
     addToDraft,
     removeFromDraft,