@cat-factory/app 0.256.3 → 0.258.0

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,

package/app/stores/pipelines/draftStepConfig.ts

@@ -1,41 +1,19 @@
-import type { BinaryOutputConfig, StepOptions } from '@cat-factory/contracts'
 import type { ConsensusStepConfig } from '~/types/consensus'
 import { defaultConsensusConfig, type PipelinesContext } from './context'
 
 /**
  * The pipeline-builder draft's PER-STEP CONFIG toggles: consensus (inline panel and the workspace
  * consensus-GROUP tier set), the human approval gate, the estimate gate on a companion step, the
- * follow-up and test-QC companions, the per-step enable flag, and the `StepOptions` bag
- * (requirements auto-recommendation, the picked skill, the picked agent-kind variant, the
- * per-step output-token ceiling, the binary-output storage/context selection). The step's GATE
- * configuration is the sibling `./draftGateConfig`, which explains why it is not here.
+ * follow-up and test-QC companions, and the per-step enable flag — every toggle that writes a
+ * PARALLEL ARRAY. The `StepOptions` bag accessors are the sibling `./draftStepOptions`, and the
+ * step's GATE configuration `./draftGateConfig`; each is split along the state it writes rather
+ * than an arbitrary line count.
  *
  * Split out of `./draftActions`, which owns the draft's STRUCTURE (insert / remove / reorder /
  * units). Every function here reads and writes one of the parallel per-step arrays at an index and
  * touches nothing else, which is what makes the two independent; both are spread into the store,
  * so the store's API is unchanged.
  */
-/**
- * Write ONE field of the step's `StepOptions` bag at `index`, merging into whatever else that step
- * carries and normalizing an emptied bag back to `null`. `undefined` CLEARS the field.
- *
- * Every per-step option below goes through this rather than repeating the clone/assign/normalize
- * dance, because the two halves that are easy to get wrong are shared by all of them: replacing
- * the bag loses the neighbouring options a step may also carry, and leaving a `{}` behind makes a
- * step that is back on every default persist a shape it never had.
- */
-function patchStepOption<K extends keyof StepOptions>(
-  draftStepOptions: PipelinesContext['draftStepOptions'],
-  index: number,
-  key: K,
-  value: StepOptions[K] | undefined,
-) {
-  const next: StepOptions = { ...draftStepOptions.value[index] }
-  if (value === undefined) delete next[key]
-  else next[key] = value
-  draftStepOptions.value[index] = Object.keys(next).length ? next : null
-}
-
 export function createPipelineStepConfigActions(ctx: PipelinesContext) {
   const {
     draftGates,
@@ -44,7 +22,6 @@ export function createPipelineStepConfigActions(ctx: PipelinesContext) {
     draftGating,
     draftFollowUps,
     draftTesterQuality,
-    draftStepOptions,
   } = ctx
 
   /** Toggle estimate gating on/off for the (companion) step at `index`. */
@@ -128,128 +105,6 @@ export function createPipelineStepConfigActions(ctx: PipelinesContext) {
     draftEnabled.value[index] = draftEnabled.value[index] === false
   }
 
-  /** Whether auto-recommendation is on for the draft (requirements-review) step at `index`. */
-  function draftAutoRecommendEnabled(index: number): boolean {
-    return draftStepOptions.value[index]?.autoRecommend !== false
-  }
-
-  /**
-   * Toggle the requirements-review auto-recommendation on the draft step at `index`. It is on by
-   * default, so we store ONLY the opt-out (`{ autoRecommend: false }`); toggling back drops the
-   * flag. Merges with any other future StepOptions fields rather than clobbering the whole bag.
-   */
-  function toggleDraftAutoRecommend(index: number) {
-    const off = draftAutoRecommendEnabled(index) ? false : undefined
-    patchStepOption(draftStepOptions, index, 'autoRecommend', off)
-  }
-
-  /**
-   * Whether the draft `deployer` step at `index` declares that its environments outlive the run
-   * (its `stepOptions.retainEnvironment`). OFF by default: the everyday shape is a run that
-   * reclaims what it stood up, and the save boundary refuses a Deployer that does neither.
-   */
-  function draftRetainEnvironment(index: number): boolean {
-    return draftStepOptions.value[index]?.retainEnvironment === true
-  }
-
-  /**
-   * Toggle the retain declaration on the draft `deployer` step at `index`. It is off by default,
-   * so we store ONLY the opt-in (the mirror of `toggleDraftAutoRecommend`, which stores only the
-   * opt-out); toggling back drops the flag and, if the bag empties, the whole entry.
-   */
-  function toggleDraftRetainEnvironment(index: number) {
-    const on = draftRetainEnvironment(index) ? undefined : true
-    patchStepOption(draftStepOptions, index, 'retainEnvironment', on)
-  }
-
-  /** The skill picked for the draft `skill` step at `index` (its `stepOptions.skillId`). */
-  function draftSkillId(index: number): string | undefined {
-    return draftStepOptions.value[index]?.skillId
-  }
-
-  /**
-   * Set (or clear) the picked skill on the draft `skill` step at `index`. Merges into the
-   * step's `StepOptions` bag rather than clobbering it; clearing drops the field and, if the
-   * bag empties, the whole entry (so it normalizes away like the other options).
-   */
-  function setDraftSkillId(index: number, skillId: string | undefined) {
-    patchStepOption(draftStepOptions, index, 'skillId', skillId || undefined)
-  }
-
-  /**
-   * The agent-kind VARIANT picked for the draft step at `index` (its
-   * `stepOptions.agentVariantId`), or undefined when it runs the kind's shipped prompt.
-   */
-  function draftAgentVariantId(index: number): string | undefined {
-    return draftStepOptions.value[index]?.agentVariantId
-  }
-
-  /**
-   * Set (or clear) the picked variant on the draft step at `index`. Merges into the step's
-   * `StepOptions` bag rather than clobbering it; clearing drops the field and, if the bag
-   * empties, the whole entry — exactly like the other options here, so a step back on the
-   * shipped prompt persists nothing.
-   */
-  function setDraftAgentVariantId(index: number, agentVariantId: string | undefined) {
-    patchStepOption(draftStepOptions, index, 'agentVariantId', agentVariantId || undefined)
-  }
-
-  /**
-   * The binary-output SELECTION on the draft step at `index` (its `stepOptions.binaryOutput`) —
-   * the foundational storage service a generator kind's artifacts are stored through, plus any
-   * services consulted for the generation's scope. Undefined on every step of every stock
-   * pipeline; required on a step whose kind carries the `binary-output` trait.
-   */
-  function draftBinaryOutput(index: number): BinaryOutputConfig | undefined {
-    return draftStepOptions.value[index]?.binaryOutput
-  }
-
-  /**
-   * Set (or clear) the binary-output selection on the draft step at `index`. Merges into the
-   * step's `StepOptions` bag rather than clobbering it; clearing drops the field and, if the
-   * bag empties, the whole entry — exactly like the other options here, so a step that never
-   * used it persists the shape it always did.
-   *
-   * An EMPTY `contextServiceIds` is dropped rather than stored, for the reason the consensus
-   * tier set drops its own empty array: the field's absence means "no scope service was
-   * selected", while `[]` reads as "context was considered and rejected" — a different claim,
-   * and one the brief renderer would repeat to the agent. `generatorIds` and `modalities` take
-   * the same treatment for the same reason: an absent `generatorIds` means the step generates
-   * through whatever its agent already has, and an absent `modalities` imposes no delivery
-   * requirement — both of which the brief STATES, so persisting `[]` would have it state the
-   * wrong thing.
-   */
-  function setDraftBinaryOutput(index: number, config: BinaryOutputConfig | undefined) {
-    const { storageServiceId, contextServiceIds, generatorIds, modalities } = config ?? {}
-    const selection = storageServiceId
-      ? {
-          storageServiceId,
-          ...(contextServiceIds?.length ? { contextServiceIds } : {}),
-          ...(generatorIds?.length ? { generatorIds } : {}),
-          ...(modalities?.length ? { modalities } : {}),
-        }
-      : undefined
-    patchStepOption(draftStepOptions, index, 'binaryOutput', selection)
-  }
-
-  /**
-   * The output-token ceiling pinned on the draft step at `index`, or undefined when the step
-   * inherits (the workspace's per-kind setting, else the deployment default).
-   */
-  function draftMaxOutputTokens(index: number): number | undefined {
-    return draftStepOptions.value[index]?.maxOutputTokens
-  }
-
-  /**
-   * Set (or clear) this step's own output-token ceiling. Merges into the step's `StepOptions`
-   * bag rather than clobbering it; clearing drops the field and, if the bag empties, the whole
-   * entry — so a step back on the inherited budget persists no options at all, exactly like the
-   * other fields here.
-   */
-  function setDraftMaxOutputTokens(index: number, maxOutputTokens: number | undefined) {
-    patchStepOption(draftStepOptions, index, 'maxOutputTokens', maxOutputTokens ?? undefined)
-  }
-
   return {
     toggleDraftGating,
     toggleDraftConsensus,
@@ -260,17 +115,5 @@ export function createPipelineStepConfigActions(ctx: PipelinesContext) {
     toggleDraftTesterQuality,
     toggleDraftTesterQualityGating,
     toggleDraftEnabled,
-    draftAutoRecommendEnabled,
-    toggleDraftAutoRecommend,
-    draftRetainEnvironment,
-    toggleDraftRetainEnvironment,
-    draftSkillId,
-    setDraftSkillId,
-    draftAgentVariantId,
-    setDraftAgentVariantId,
-    draftBinaryOutput,
-    setDraftBinaryOutput,
-    draftMaxOutputTokens,
-    setDraftMaxOutputTokens,
   }
 }

package/app/stores/pipelines/draftStepOptions.ts

@@ -0,0 +1,204 @@
+import type { BinaryOutputConfig, StepOptions, StepServiceScope } from '@cat-factory/contracts'
+import type { PipelinesContext } from './context'
+
+/**
+ * The pipeline-builder draft's `StepOptions` BAG accessors: every per-step parameter that lives in
+ * the one extensible options object rather than in a parallel array of its own — the requirements
+ * auto-recommendation, the Deployer's retain declaration, the step's run CONDITION, the picked
+ * skill, the picked agent-kind variant, the binary-output selection, and the per-step output-token
+ * ceiling.
+ *
+ * Its own module for the reason `./draftGateConfig` is: the sibling `./draftStepConfig` owns the
+ * per-step TOGGLES that each write a parallel array, while every function here reads and writes
+ * one FIELD of one bag through {@link patchStepOption}. The split is along that seam rather than
+ * an arbitrary line count, so a new per-step knob has an obvious home — and since the bag is the
+ * declared home for every NEW knob, this is the half that keeps growing.
+ */
+
+/**
+ * Write ONE field of the step's `StepOptions` bag at `index`, merging into whatever else that step
+ * carries and normalizing an emptied bag back to `null`. `undefined` CLEARS the field.
+ *
+ * Every per-step option below goes through this rather than repeating the clone/assign/normalize
+ * dance, because the two halves that are easy to get wrong are shared by all of them: replacing
+ * the bag loses the neighbouring options a step may also carry, and leaving a `{}` behind makes a
+ * step that is back on every default persist a shape it never had.
+ */
+function patchStepOption<K extends keyof StepOptions>(
+  draftStepOptions: PipelinesContext['draftStepOptions'],
+  index: number,
+  key: K,
+  value: StepOptions[K] | undefined,
+) {
+  const next: StepOptions = { ...draftStepOptions.value[index] }
+  if (value === undefined) delete next[key]
+  else next[key] = value
+  draftStepOptions.value[index] = Object.keys(next).length ? next : null
+}
+
+export function createPipelineStepOptionActions(ctx: PipelinesContext) {
+  const { draftStepOptions } = ctx
+
+  /** Whether auto-recommendation is on for the draft (requirements-review) step at `index`. */
+  function draftAutoRecommendEnabled(index: number): boolean {
+    return draftStepOptions.value[index]?.autoRecommend !== false
+  }
+
+  /**
+   * Toggle the requirements-review auto-recommendation on the draft step at `index`. It is on by
+   * default, so we store ONLY the opt-out (`{ autoRecommend: false }`); toggling back drops the
+   * flag. Merges with any other future StepOptions fields rather than clobbering the whole bag.
+   */
+  function toggleDraftAutoRecommend(index: number) {
+    const off = draftAutoRecommendEnabled(index) ? false : undefined
+    patchStepOption(draftStepOptions, index, 'autoRecommend', off)
+  }
+
+  /**
+   * Whether the draft `deployer` step at `index` declares that its environments outlive the run
+   * (its `stepOptions.retainEnvironment`). OFF by default: the everyday shape is a run that
+   * reclaims what it stood up, and the save boundary refuses a Deployer that does neither.
+   */
+  function draftRetainEnvironment(index: number): boolean {
+    return draftStepOptions.value[index]?.retainEnvironment === true
+  }
+
+  /**
+   * Toggle the retain declaration on the draft `deployer` step at `index`. It is off by default,
+   * so we store ONLY the opt-in (the mirror of `toggleDraftAutoRecommend`, which stores only the
+   * opt-out); toggling back drops the flag and, if the bag empties, the whole entry.
+   */
+  function toggleDraftRetainEnvironment(index: number) {
+    const on = draftRetainEnvironment(index) ? undefined : true
+    patchStepOption(draftStepOptions, index, 'retainEnvironment', on)
+  }
+
+  /**
+   * The RUN CONDITION on the draft step at `index` — the service scope it applies to, or
+   * `undefined` when it runs on every task (`stepOptions.condition`).
+   */
+  function draftStepCondition(index: number): StepServiceScope | undefined {
+    return draftStepOptions.value[index]?.condition?.serviceScope
+  }
+
+  /**
+   * Cycle the draft step's run condition: unconditional → frontend-only → backend-only →
+   * unconditional.
+   *
+   * A CYCLE rather than a picker because the states are three and mutually exclusive, and the
+   * control has to live in a dense per-step icon row beside eight others. It cycles back to
+   * unconditional deliberately: a condition arrives on a step by CLONING a built-in (the tester
+   * pair), so the state a user most needs to reach from here is the one that clears it.
+   */
+  function cycleDraftStepCondition(index: number) {
+    const current = draftStepCondition(index)
+    const next: StepServiceScope | undefined =
+      current === undefined ? 'frontend' : current === 'frontend' ? 'backend' : undefined
+    patchStepOption(draftStepOptions, index, 'condition', next ? { serviceScope: next } : undefined)
+  }
+
+  /** The skill picked for the draft `skill` step at `index` (its `stepOptions.skillId`). */
+  function draftSkillId(index: number): string | undefined {
+    return draftStepOptions.value[index]?.skillId
+  }
+
+  /**
+   * Set (or clear) the picked skill on the draft `skill` step at `index`. Merges into the
+   * step's `StepOptions` bag rather than clobbering it; clearing drops the field and, if the
+   * bag empties, the whole entry (so it normalizes away like the other options).
+   */
+  function setDraftSkillId(index: number, skillId: string | undefined) {
+    patchStepOption(draftStepOptions, index, 'skillId', skillId || undefined)
+  }
+
+  /**
+   * The agent-kind VARIANT picked for the draft step at `index` (its
+   * `stepOptions.agentVariantId`), or undefined when it runs the kind's shipped prompt.
+   */
+  function draftAgentVariantId(index: number): string | undefined {
+    return draftStepOptions.value[index]?.agentVariantId
+  }
+
+  /**
+   * Set (or clear) the picked variant on the draft step at `index`. Merges into the step's
+   * `StepOptions` bag rather than clobbering it; clearing drops the field and, if the bag
+   * empties, the whole entry — exactly like the other options here, so a step back on the
+   * shipped prompt persists nothing.
+   */
+  function setDraftAgentVariantId(index: number, agentVariantId: string | undefined) {
+    patchStepOption(draftStepOptions, index, 'agentVariantId', agentVariantId || undefined)
+  }
+
+  /**
+   * The binary-output SELECTION on the draft step at `index` (its `stepOptions.binaryOutput`) —
+   * the foundational storage service a generator kind's artifacts are stored through, plus any
+   * services consulted for the generation's scope. Undefined on every step of every stock
+   * pipeline; required on a step whose kind carries the `binary-output` trait.
+   */
+  function draftBinaryOutput(index: number): BinaryOutputConfig | undefined {
+    return draftStepOptions.value[index]?.binaryOutput
+  }
+
+  /**
+   * Set (or clear) the binary-output selection on the draft step at `index`. Merges into the
+   * step's `StepOptions` bag rather than clobbering it; clearing drops the field and, if the
+   * bag empties, the whole entry — exactly like the other options here, so a step that never
+   * used it persists the shape it always did.
+   *
+   * An EMPTY `contextServiceIds` is dropped rather than stored, for the reason the consensus
+   * tier set drops its own empty array: the field's absence means "no scope service was
+   * selected", while `[]` reads as "context was considered and rejected" — a different claim,
+   * and one the brief renderer would repeat to the agent. `generatorIds` and `modalities` take
+   * the same treatment for the same reason: an absent `generatorIds` means the step generates
+   * through whatever its agent already has, and an absent `modalities` imposes no delivery
+   * requirement — both of which the brief STATES, so persisting `[]` would have it state the
+   * wrong thing.
+   */
+  function setDraftBinaryOutput(index: number, config: BinaryOutputConfig | undefined) {
+    const { storageServiceId, contextServiceIds, generatorIds, modalities } = config ?? {}
+    const selection = storageServiceId
+      ? {
+          storageServiceId,
+          ...(contextServiceIds?.length ? { contextServiceIds } : {}),
+          ...(generatorIds?.length ? { generatorIds } : {}),
+          ...(modalities?.length ? { modalities } : {}),
+        }
+      : undefined
+    patchStepOption(draftStepOptions, index, 'binaryOutput', selection)
+  }
+
+  /**
+   * The output-token ceiling pinned on the draft step at `index`, or undefined when the step
+   * inherits (the workspace's per-kind setting, else the deployment default).
+   */
+  function draftMaxOutputTokens(index: number): number | undefined {
+    return draftStepOptions.value[index]?.maxOutputTokens
+  }
+
+  /**
+   * Set (or clear) this step's own output-token ceiling. Merges into the step's `StepOptions`
+   * bag rather than clobbering it; clearing drops the field and, if the bag empties, the whole
+   * entry — so a step back on the inherited budget persists no options at all, exactly like the
+   * other fields here.
+   */
+  function setDraftMaxOutputTokens(index: number, maxOutputTokens: number | undefined) {
+    patchStepOption(draftStepOptions, index, 'maxOutputTokens', maxOutputTokens ?? undefined)
+  }
+
+  return {
+    draftAutoRecommendEnabled,
+    toggleDraftAutoRecommend,
+    draftRetainEnvironment,
+    toggleDraftRetainEnvironment,
+    draftStepCondition,
+    cycleDraftStepCondition,
+    draftSkillId,
+    setDraftSkillId,
+    draftAgentVariantId,
+    setDraftAgentVariantId,
+    draftBinaryOutput,
+    setDraftBinaryOutput,
+    draftMaxOutputTokens,
+    setDraftMaxOutputTokens,
+  }
+}

package/app/stores/ui/resultViews.ts

@@ -164,12 +164,13 @@ export function createUiResultViews() {
   // The run-scoped openers (a caller that knows only the RUN, so the step index has to be
   // resolved) live in a sibling module: they share one shape and one hazard, and lifting them out
   // keeps this factory inside its per-function line budget. Their two seams are bound here.
-  const { openFollowUps, openForkDecision, openPrReview, openTestEvidence } = createRunStepOpeners({
-    dispatchStepView: (instanceId, stepIndex) => dispatchStepView(instanceId, stepIndex),
-    setResultView: (view, instance, stepIndex) => {
-      resultView.value = { view, blockId: instance.blockId, instanceId: instance.id, stepIndex }
-    },
-  })
+  const { openFollowUps, openForkDecision, openBinaryCandidates, openPrReview, openTestEvidence } =
+    createRunStepOpeners({
+      dispatchStepView: (instanceId, stepIndex) => dispatchStepView(instanceId, stepIndex),
+      setResultView: (view, instance, stepIndex) => {
+        resultView.value = { view, blockId: instance.blockId, instanceId: instance.id, stepIndex }
+      },
+    })
 
   function closeResultView() {
     resultView.value = null
@@ -209,6 +210,7 @@ export function createUiResultViews() {
     openInitiativePlanning,
     openFollowUps,
     openForkDecision,
+    openBinaryCandidates,
     openPrReview,
     openTestEvidence,
     openOutcome,

package/app/stores/ui/runStepOpeners.ts

@@ -93,6 +93,28 @@ export function createRunStepOpeners(deps: RunStepOpenerDeps) {
     )
   }
 
+  // Open the generated-candidate comparison window for a run's binary-output step (from the
+  // pipeline chip / inspector rail / step overlay). Resolves the step index from the run when not
+  // given, preferring the step parked awaiting a choice.
+  //
+  // Resolved by the CANDIDATE STATE rather than by an agent kind, unlike its neighbours: any kind
+  // carrying the `binary-output` trait can run a comparison, and a deployment's own kinds are
+  // exactly the ones a hard-coded kind list here would never name.
+  function openBinaryCandidates(instanceId: string, stepIndex: number | null = null) {
+    withStep(
+      instanceId,
+      stepIndex,
+      (instance) => {
+        const awaiting = indexOf(instance, (s) => s.binaryCandidates?.status === 'awaiting_choice')
+        if (awaiting >= 0) return awaiting
+        const current = instance.steps[instance.currentStep]
+        if (current?.binaryCandidates) return instance.currentStep
+        return indexOf(instance, (s) => !!s.binaryCandidates)
+      },
+      (instance, idx) => deps.setResultView('binary-candidates', instance, idx),
+    )
+  }
+
   // Open the PR deep-review window for a run's `pr-reviewer` step (from the `pr_review_ready`
   // notification / the step). Resolves the step index from the run when not given, preferring
   // the step parked awaiting a finding selection.
@@ -139,5 +161,5 @@ export function createRunStepOpeners(deps: RunStepOpenerDeps) {
     )
   }
 
-  return { openFollowUps, openForkDecision, openPrReview, openTestEvidence }
+  return { openFollowUps, openForkDecision, openBinaryCandidates, openPrReview, openTestEvidence }
 }

package/app/types/domain.ts

@@ -164,6 +164,12 @@ export interface AgentArchetype {
    * which is every built-in kind.
    */
   binaryOutput?: boolean
+  /**
+   * The platform dispatches this kind for a flow of its own, so the builder palette never offers
+   * it as a placeable block (`narrowAgentPalette` drops it). It still resolves through
+   * `agentKindMeta`, because a run of it has to RENDER. Absent ⇒ an ordinary palette block.
+   */
+  internal?: boolean
 }
 
 /**

package/app/types/execution.ts

@@ -95,6 +95,11 @@ export type {
   BinaryOutputArtifact,
   BinaryOutputConfig,
   BinaryOutputReport,
+  // The candidate-comparison set on a step whose selection declares a `comparison`: the staged
+  // candidates, the live park state, and the human's keep/discard decision.
+  BinaryCandidate,
+  BinaryCandidateChoice,
+  BinaryCandidateStepState,
   TesterStepState,
   HumanTestEnvironment,
   RunEnvironment,

package/app/utils/agentPalette.spec.ts

@@ -33,6 +33,32 @@ const CATALOG: AgentArchetype[] = [
   archetype('acme-auditor'),
 ]
 
+describe('narrowAgentPalette — internal kinds', () => {
+  // An INTERNAL kind is one the platform dispatches for a flow of its own (the environment
+  // analyst, which hands its draft to the setup wizard). It is not hidden by a dial, it is not a
+  // palette block at all.
+  const internal: AgentArchetype = {
+    ...archetype('environment-analyst', 'design', 'basic'),
+    internal: true,
+  }
+  const catalog = [archetype('architect', 'design', 'basic'), internal]
+
+  it('never offers one, at any purpose or tier', () => {
+    for (const tier of ['basic', 'intermediate', 'advanced'] as const) {
+      const { offered } = narrowAgentPalette(catalog, 'build', tier)
+      expect(offered.map((a) => a.kind)).toEqual(['architect'])
+    }
+  })
+
+  it('counts one against NEITHER dial, so no hint promises a control that would reveal it', () => {
+    // The whole point of the counts is "relax THIS dial and you get n more". An internal kind is
+    // revealed by neither, so counting it would send a reader chasing a control that cannot help.
+    const { hiddenByPurpose, hiddenByTier } = narrowAgentPalette(catalog, 'review', 'basic')
+    expect(hiddenByPurpose).toBe(1) // the architect alone: a review pipeline designs nothing
+    expect(hiddenByTier).toBe(0)
+  })
+})
+
 describe('narrowAgentPalette', () => {
   it('narrows nothing for a build pipeline at the widest tier', () => {
     const { offered, hiddenByPurpose, hiddenByTier } = narrowAgentPalette(