@cat-factory/app 0.202.0 → 0.205.0

package/app/modular/tutorial-tours.spec.ts

@@ -2,10 +2,14 @@ import { readdirSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { describe, expect, it } from 'vitest'
 import en from '../../i18n/locales/en.json'
-import { TUTORIAL_TOURS, tutorialToursModule } from '~/modular/tutorial-tours'
-import { NAV_CONTRIBUTIONS, navSlotFilter } from '~/modular/nav-contributions'
+import {
+  TUTORIAL_REQUIREMENTS,
+  TUTORIAL_TOURS,
+  tutorialToursModule,
+} from '~/modular/tutorial-tours'
+import { resolveTourCatalogue, resolveTours } from '~/utils/tutorial'
 import { isSafeTargetId } from '~/components/tutorial/TutorialOverlay.logic'
-import type { AppSlots, NavGates } from '~/modular/nav-contributions'
+import type { NavGates } from '~/modular/nav-contributions'
 
 const ALL_GATES: NavGates = {
   canWriteBoard: true,
@@ -40,12 +44,6 @@ const FRESH_BOARD: NavGates = {
   boardHasFinishedRun: false,
 }
 
-const slots = (): AppSlots =>
-  ({
-    nav: [...NAV_CONTRIBUTIONS],
-    tutorialTours: [...TUTORIAL_TOURS],
-  }) as unknown as AppSlots
-
 /** Resolve a dot-path against the en catalog; undefined when any hop is missing. */
 function lookupKey(key: string): unknown {
   return key
@@ -197,73 +195,124 @@ describe('the built-in tutorial tour catalog', () => {
   })
 })
 
-describe('navSlotFilter over tutorialTours', () => {
-  it('keeps every tour for a fully-gated user', () => {
-    const filtered = navSlotFilter(slots(), { gates: ALL_GATES })
-    expect(filtered.tutorialTours.map((t) => t.id)).toEqual(TUTORIAL_TOURS.map((t) => t.id))
+describe('tour availability across the catalog', () => {
+  /** The ids a board can START right now — what the launch prompt offers. */
+  const ready = (gates: NavGates) => resolveTours(TUTORIAL_TOURS, gates).map((t) => t.id)
+  /** The catalogue's own view: every tour, with what is holding each one back. */
+  const entry = (gates: NavGates, tourId: string) =>
+    resolveTourCatalogue(TUTORIAL_TOURS, gates).find((e) => e.tour.id === tourId)
+
+  it('offers every tour to a fully-gated user on a fully-populated board', () => {
+    expect(ready(ALL_GATES)).toEqual(TUTORIAL_TOURS.map((t) => t.id))
   })
 
-  it('drops the task-creating tour for a read-only viewer', () => {
+  it('lists the whole catalog whatever the gates say, holding back rather than hiding', () => {
+    // The catalogue surface's contract. A fresh board can run two of the six walkthroughs;
+    // dropping the other four (all a slot filter could do) would misrepresent the product as
+    // shipping two, to exactly the user who came looking for the rest.
+    const catalogue = resolveTourCatalogue(TUTORIAL_TOURS, FRESH_BOARD)
+    expect(catalogue.map((e) => e.tour.id)).toEqual(TUTORIAL_TOURS.map((t) => t.id))
+    expect(catalogue.filter((e) => e.availability === 'ready').map((e) => e.tour.id)).toEqual([
+      'board-basics',
+      'add-service',
+    ])
+  })
+
+  it('holds the task-creating tour back from a read-only viewer, and says why', () => {
     const viewer: NavGates = { ...ALL_GATES, canWriteBoard: false }
-    const filtered = navSlotFilter(slots(), { gates: viewer })
-    const ids = filtered.tutorialTours.map((t) => t.id)
-    expect(ids).toContain('board-basics')
-    expect(ids).not.toContain('first-task')
+    expect(ready(viewer)).toContain('board-basics')
+    expect(ready(viewer)).not.toContain('first-task')
+    expect(entry(viewer, 'first-task')?.unmet.map((r) => r.id)).toEqual(['board-write'])
   })
 
-  it('drops the task-creating tour on a board with no service to add a task to', () => {
+  it('holds the task-creating tour back on a board with no service to add a task to', () => {
     // Every targeted step of that tour would time out in turn and it would then claim to
     // have taught the core loop; `board-basics` is what an empty board can deliver.
     const emptyBoard: NavGates = { ...ALL_GATES, boardHasService: false }
-    const filtered = navSlotFilter(slots(), { gates: emptyBoard })
-    expect(filtered.tutorialTours.map((t) => t.id)).not.toContain('first-task')
+    expect(ready(emptyBoard)).not.toContain('first-task')
+    expect(entry(emptyBoard, 'first-task')?.unmet.map((r) => r.id)).toEqual(['service'])
   })
 
   it('offers a brand-new board the orientation tour AND the way out of being empty', () => {
     // The state the launch prompt actually auto-opens in. Orientation alone would leave a
     // new workspace with a tour of an empty canvas and no route to a first service, which
     // is what `add-service` exists to fix — so it must survive exactly this gate set.
-    const filtered = navSlotFilter(slots(), { gates: FRESH_BOARD })
-    expect(filtered.tutorialTours.map((t) => t.id)).toEqual(['board-basics', 'add-service'])
+    expect(ready(FRESH_BOARD)).toEqual(['board-basics', 'add-service'])
   })
 
-  it('drops the repo tour when no source-control connection can list repositories', () => {
+  it('names the missing connection when no source control can list repositories', () => {
     const noSource: NavGates = { ...FRESH_BOARD, githubAvailable: false }
-    expect(navSlotFilter(slots(), { gates: noSource }).tutorialTours.map((t) => t.id)).toEqual([
-      'board-basics',
-    ])
+    expect(ready(noSource)).toEqual(['board-basics'])
+    expect(entry(noSource, 'add-service')?.unmet.map((r) => r.id)).toEqual(['source-control'])
   })
 
   it('offers the run tour once a task exists, and the review tour once a run finished', () => {
     const withTask: NavGates = { ...FRESH_BOARD, boardHasService: true, boardHasTask: true }
-    expect(navSlotFilter(slots(), { gates: withTask }).tutorialTours.map((t) => t.id)).toContain(
-      'run-task',
-    )
-    expect(
-      navSlotFilter(slots(), { gates: withTask }).tutorialTours.map((t) => t.id),
-    ).not.toContain('review-merge')
+    expect(ready(withTask)).toContain('run-task')
+    expect(ready(withTask)).not.toContain('review-merge')
+    expect(entry(withTask, 'review-merge')?.unmet.map((r) => r.id)).toEqual(['finished-run'])
 
     const finished: NavGates = { ...withTask, boardHasRun: true, boardHasFinishedRun: true }
-    expect(navSlotFilter(slots(), { gates: finished }).tutorialTours.map((t) => t.id)).toContain(
-      'review-merge',
-    )
+    expect(ready(finished)).toContain('review-merge')
+  })
+
+  it('names every unmet requirement, not just the first', () => {
+    // The reader has to do all of them; reporting one at a time turns unblocking a tour into
+    // a guessing game with a fresh answer after each attempt.
+    const bare: NavGates = { ...FRESH_BOARD, canWriteBoard: false, githubAvailable: false }
+    expect(entry(bare, 'add-service')?.unmet.map((r) => r.id)).toEqual([
+      'board-write',
+      'source-control',
+    ])
+  })
+
+  it('resolves every requirement copy key against the en catalog', () => {
+    // Same tier-2 i18n guard as the tour copy above: a requirement's label is looked up from
+    // data, so a renamed key would reach the user as a raw path in the "available once" list.
+    for (const requirement of Object.values(TUTORIAL_REQUIREMENTS)) {
+      expect(typeof lookupKey(requirement.labelKey), requirement.labelKey).toBe('string')
+    }
+  })
+
+  it('gives every tour a step that always applies, so none can be listed then not run', () => {
+    // The authoring rule `resolveTourCatalogue` documents. `blocked` outranks `not-applicable`,
+    // which is right — but it means a tour COULD be named in the catalogue as unlockable and
+    // then, once the reader has gone and done the thing it asked for, resolve to no applicable
+    // steps and still refuse to start. An unconditional step (every built-in has an intro and a
+    // finish card) makes `steps` non-empty under any gates, so that outcome is unreachable.
+    for (const tour of TUTORIAL_TOURS) {
+      const unconditional = tour.steps.filter((s) => !s.when).map((s) => s.id)
+      expect(unconditional, tour.id).not.toEqual([])
+    }
+  })
+
+  it('declares its requirements from the shared set', () => {
+    // A tour with an inline requirement object is not wrong, but a duplicate of a shared one
+    // is: two copies of "a service on the board" drift into two different sentences about the
+    // same gate. Pinning the built-ins to the table keeps that a deliberate act.
+    const shared = new Set(Object.values(TUTORIAL_REQUIREMENTS).map((r) => r.id))
+    for (const tour of TUTORIAL_TOURS) {
+      for (const requirement of tour.requires ?? []) {
+        expect(shared, `${tour.id}: ${requirement.id}`).toContain(requirement.id)
+      }
+    }
   })
 
   it('passes tours through untouched when no gates service is wired', () => {
-    const filtered = navSlotFilter(slots(), {})
-    expect(filtered.tutorialTours.map((t) => t.id)).toEqual(TUTORIAL_TOURS.map((t) => t.id))
+    expect(resolveTours(TUTORIAL_TOURS, null).map((t) => t.id)).toEqual(
+      TUTORIAL_TOURS.map((t) => t.id),
+    )
   })
 })
 
 describe('the parked-run tour branches', () => {
   const stepIds = (gates: NavGates, tourId: string) =>
-    navSlotFilter(slots(), { gates })
-      .tutorialTours.find((t) => t.id === tourId)
+    resolveTours(TUTORIAL_TOURS, gates)
+      .find((t) => t.id === tourId)
       ?.steps.map((s) => s.id)
 
   it('is not offered while nothing is waiting for a human', () => {
-    const ids = navSlotFilter(slots(), { gates: FRESH_BOARD }).tutorialTours.map((t) => t.id)
-    expect(ids).not.toContain('answer-park')
+    expect(resolveTours(TUTORIAL_TOURS, FRESH_BOARD).map((t) => t.id)).not.toContain('answer-park')
   })
 
   it('shows the decision branch only, for a run parked on a decision', () => {
@@ -297,7 +346,7 @@ describe('the parked-run tour branches', () => {
   it('keeps every branch when no gates service is wired', () => {
     // Same dev-open parity as `nav`: with nothing to gate against, nothing is withheld —
     // including the per-step branches, which a bare install must not silently thin out.
-    const answerPark = navSlotFilter(slots(), {}).tutorialTours.find((t) => t.id === 'answer-park')
+    const answerPark = resolveTours(TUTORIAL_TOURS, null).find((t) => t.id === 'answer-park')
     expect(answerPark?.steps.map((s) => s.id)).toEqual([
       'intro',
       'resolve',

package/app/modular/tutorial-tours.ts

@@ -1,5 +1,5 @@
 import { defineModule } from '@modular-vue/core'
-import type { TutorialTour } from '~/utils/tutorial'
+import type { TutorialRequirement, TutorialTour } from '~/utils/tutorial'
 
 /**
  * The first-party tutorial-tour catalog, contributed to the `tutorialTours` slot the same
@@ -27,11 +27,15 @@ import type { TutorialTour } from '~/utils/tutorial'
  *  - A step whose branch of the flow this board simply isn't on declares `when`, so it is
  *    DROPPED rather than skipped: a skip is reported as an abridged tour, and a parked run
  *    that has a decision and no approval gate is not an abridged anything.
+ *  - A tour's own preconditions are DECLARED ({@link TUTORIAL_REQUIREMENTS}), never an
+ *    anonymous predicate: the catalogue lists every tour this deployment ships and has to say
+ *    what a user must do before one it is holding back becomes available.
  *
  * Together the tours below walk the delivery loop end to end — get a repo onto the board,
  * put a task on it, run it, answer it when it asks, read the result and merge it — with each
- * later tour gated on the state the previous one produces, so the launch prompt only ever
- * offers what this board can actually demonstrate.
+ * later tour requiring the state the previous one produces, so the launch prompt only ever
+ * offers what this board can actually demonstrate, and the catalogue turns the rest into a
+ * to-do list rather than an absence.
  */
 
 /**
@@ -43,6 +47,51 @@ import type { TutorialTour } from '~/utils/tutorial'
  */
 export const SAMPLE_REPO = 'kibertoad/cat-factory-sample-repository'
 
+/**
+ * The preconditions the built-in tours declare, each pairing the gate that decides it with
+ * the copy that NAMES it — so a tour the board can't run yet is listed with the one thing
+ * still missing instead of being silently absent from the catalogue.
+ *
+ * Shared constants rather than a literal per tour because several tours need the same fact
+ * (`service` gates two of them), and a second copy of a requirement is a second reason string
+ * to keep in step with the gate it describes.
+ */
+export const TUTORIAL_REQUIREMENTS = {
+  boardWrite: {
+    id: 'board-write',
+    labelKey: 'tutorial.requirements.boardWrite',
+    met: (gates) => gates.canWriteBoard,
+  },
+  sourceControl: {
+    id: 'source-control',
+    labelKey: 'tutorial.requirements.sourceControl',
+    met: (gates) => gates.githubAvailable,
+  },
+  service: {
+    id: 'service',
+    labelKey: 'tutorial.requirements.service',
+    met: (gates) => gates.boardHasService,
+  },
+  task: {
+    id: 'task',
+    labelKey: 'tutorial.requirements.task',
+    met: (gates) => gates.boardHasTask,
+  },
+  // One requirement over both kinds of park, mirroring the tour's single `task-resolve`
+  // anchor: the card offers ONE attention action whichever way a run is waiting, so splitting
+  // this would list two things to go and do where either one alone unlocks the tour.
+  waitingAnswer: {
+    id: 'waiting-answer',
+    labelKey: 'tutorial.requirements.waitingAnswer',
+    met: (gates) => gates.boardHasOpenDecision || gates.boardHasPendingApproval,
+  },
+  finishedRun: {
+    id: 'finished-run',
+    labelKey: 'tutorial.requirements.finishedRun',
+    met: (gates) => gates.boardHasFinishedRun,
+  },
+} as const satisfies Record<string, TutorialRequirement>
+
 export const TUTORIAL_TOURS: readonly TutorialTour[] = [
   {
     id: 'board-basics',
@@ -116,7 +165,7 @@ export const TUTORIAL_TOURS: readonly TutorialTour[] = [
     // repo is a board write against a connected source, and in basic interface mode
     // add-from-repo is the ONLY route (bootstrap is advanced), which is what makes this
     // worth a tour rather than a hint.
-    when: (gates) => gates.canWriteBoard && gates.githubAvailable,
+    requires: [TUTORIAL_REQUIREMENTS.boardWrite, TUTORIAL_REQUIREMENTS.sourceControl],
     steps: [
       {
         id: 'intro',
@@ -172,7 +221,7 @@ export const TUTORIAL_TOURS: readonly TutorialTour[] = [
     // hunting for controls and then claim to have taught the core loop. Offering it only
     // once a service exists is the honest version — and the launch prompt still lists
     // `board-basics`, which is the tour an empty board can actually deliver.
-    when: (gates) => gates.canWriteBoard && gates.boardHasService,
+    requires: [TUTORIAL_REQUIREMENTS.boardWrite, TUTORIAL_REQUIREMENTS.service],
     steps: [
       {
         id: 'intro',
@@ -236,7 +285,7 @@ export const TUTORIAL_TOURS: readonly TutorialTour[] = [
     // pipeline it will run, the start control, the live step list. `first-task` stops at the
     // card, so without this tour a user who finished the shipped walkthrough has never seen
     // the inspector. Needs a task to open, not merely a service to hold one.
-    when: (gates) => gates.canWriteBoard && gates.boardHasTask,
+    requires: [TUTORIAL_REQUIREMENTS.boardWrite, TUTORIAL_REQUIREMENTS.task],
     steps: [
       {
         id: 'intro',
@@ -306,7 +355,7 @@ export const TUTORIAL_TOURS: readonly TutorialTour[] = [
     // realise a run is asking them something has a run that never finishes and a workspace
     // in-flight slot held open. Offered only while something is actually waiting, because
     // the whole tour anchors on controls that exist only then.
-    when: (gates) => gates.boardHasOpenDecision || gates.boardHasPendingApproval,
+    requires: [TUTORIAL_REQUIREMENTS.waitingAnswer],
     steps: [
       {
         id: 'intro',
@@ -361,7 +410,7 @@ export const TUTORIAL_TOURS: readonly TutorialTour[] = [
     // The last mile: a task is only DONE when its PR actually merged, so a user who never
     // finds the result and the merge control has a board full of finished-looking work that
     // shipped nothing. Its subject is a run's output, so it needs a run that produced one.
-    when: (gates) => gates.boardHasFinishedRun,
+    requires: [TUTORIAL_REQUIREMENTS.finishedRun],
     steps: [
       {
         id: 'intro',

package/app/pages/index.vue

@@ -142,11 +142,15 @@ const AiPresetMismatchDialog = defineAsyncComponent(
   () => import('~/components/providers/AiPresetMismatchDialog.vue'),
 )
 // The in-app tutorial: the launch prompt (auto-opened once for a user who never answered
-// it) and the coach-mark overlay that runs a tour. Both mount only while their store flag
-// is set, so they cost the initial bundle nothing.
+// it), the catalogue of every tour the deployment ships (opened from the sidebar's Help
+// section or the palette, at any time), and the coach-mark overlay that runs a tour. All
+// mount only while their store flag is set, so they cost the initial bundle nothing.
 const TutorialPrompt = defineAsyncComponent(
   () => import('~/components/tutorial/TutorialPrompt.vue'),
 )
+const TutorialCatalogue = defineAsyncComponent(
+  () => import('~/components/tutorial/TutorialCatalogue.vue'),
+)
 const TutorialOverlay = defineAsyncComponent(
   () => import('~/components/tutorial/TutorialOverlay.vue'),
 )
@@ -512,6 +516,7 @@ watch(
       <AiProviderOnboardingModal v-if="ui.aiProviderSetupOpen" />
       <AiPresetMismatchDialog v-if="ui.aiPresetMismatchOpen" />
       <TutorialPrompt v-if="tutorial.promptOpen" />
+      <TutorialCatalogue v-if="tutorial.catalogueOpen" />
       <TutorialOverlay v-if="tutorial.touring" />
     </template>
 

package/app/stores/agents.ts

@@ -10,6 +10,7 @@ import {
   SYSTEM_AGENT_META,
   uid,
 } from '~/utils/catalog'
+import type { RegisteredBinaryGenerator } from '@cat-factory/contracts'
 import type { AgentArchetype, AgentKind, AgentKindVariant, CustomAgentKind } from '~/types/domain'
 
 /**
@@ -45,6 +46,13 @@ export const useAgentsStore = defineStore('agents', () => {
   // there — so folding it into the kind catalog would make it placeable, which is exactly what
   // the backend model says it is not. A straight replace, like the skills catalog it mirrors.
   const variants = ref<AgentKindVariant[]>([])
+  /**
+   * The deployment's GENERATIVE BINARY INTEGRATIONS, from the workspace snapshot. Static
+   * deployment-registered composition data like {@link variants}, and it rides the same store for
+   * the same reason: it is a fact ABOUT the agent catalog that the pipeline builder branches on,
+   * with no workspace state behind it. Empty on the stock product — the platform ships none.
+   */
+  const binaryGenerators = ref<RegisteredBinaryGenerator[]>([])
 
   /**
    * The merged CUSTOM catalog (consumer-slot → backend-manifest → runtime), each
@@ -140,6 +148,16 @@ export const useAgentsStore = defineStore('agents', () => {
     capabilitiesManifest.value = manifest
   }
 
+  /**
+   * Hydrate the deployment's registered generative binary integrations from the snapshot (a
+   * straight replace, like {@link hydrateVariants}). The builder's binary-output picker offers
+   * exactly these ids, so they are the same set run admission resolves a step's `generatorIds`
+   * against — an id offered from anywhere else would save clean and be refused at run START.
+   */
+  function hydrateBinaryGenerators(list: readonly RegisteredBinaryGenerator[]) {
+    binaryGenerators.value = [...list]
+  }
+
   /** Hydrate the deployment's registered agent-kind variants from the snapshot (straight replace). */
   function hydrateVariants(list: readonly AgentKindVariant[]) {
     variants.value = [...list]
@@ -172,6 +190,8 @@ export const useAgentsStore = defineStore('agents', () => {
     variants,
     hydrateVariants,
     variantsForKind,
+    binaryGenerators,
+    hydrateBinaryGenerators,
     variantLabel,
   }
 })

package/app/stores/pipelines/draftBinaryOutput.spec.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest'
+import { usePipelinesStore } from '~/stores/pipelines'
+
+/**
+ * The pipeline-builder draft's binary-output selection (`stepOptions.binaryOutput`), the store
+ * half of the picker (docs/initiatives/binary-output-foundational-storage.md). Same contract as
+ * the skill and variant helpers beside it — merge into the options bag, normalize an emptied bag
+ * back to null — plus the one rule specific to this field: an empty `contextServiceIds` is
+ * DROPPED rather than persisted, because `[]` and absence are different claims to the agent.
+ */
+describe('pipelines store — per-step binary-output selection', () => {
+  it('sets, reads and clears the selection', () => {
+    const pipelines = usePipelinesStore()
+    pipelines.addToDraft('coder')
+    expect(pipelines.draftBinaryOutput(0)).toBeUndefined()
+
+    pipelines.setDraftBinaryOutput(0, { storageServiceId: 'file-storage' })
+    expect(pipelines.draftBinaryOutput(0)).toEqual({ storageServiceId: 'file-storage' })
+    expect(pipelines.draftStepOptions[0]).toEqual({
+      binaryOutput: { storageServiceId: 'file-storage' },
+    })
+
+    // Clearing drops the field and, with the bag now empty, normalizes the entry back to null —
+    // so a step that never used it persists exactly the shape it always did.
+    pipelines.setDraftBinaryOutput(0, undefined)
+    expect(pipelines.draftBinaryOutput(0)).toBeUndefined()
+    expect(pipelines.draftStepOptions[0]).toBeNull()
+  })
+
+  // `[]` reads as "context was considered and rejected", which the brief would then repeat to
+  // the agent; absence reads as "no scope service was selected". Only one of those is true.
+  it('drops an emptied context list rather than persisting an empty array', () => {
+    const pipelines = usePipelinesStore()
+    pipelines.addToDraft('coder')
+
+    pipelines.setDraftBinaryOutput(0, {
+      storageServiceId: 'file-storage',
+      contextServiceIds: ['asset-management'],
+    })
+    expect(pipelines.draftBinaryOutput(0)?.contextServiceIds).toEqual(['asset-management'])
+
+    pipelines.setDraftBinaryOutput(0, { storageServiceId: 'file-storage', contextServiceIds: [] })
+    expect(pipelines.draftBinaryOutput(0)).toEqual({ storageServiceId: 'file-storage' })
+  })
+
+  // A blank storage id is not a selection: the backend refuses the step either way, so the
+  // draft must not carry a half-filled shape that saves and then fails.
+  it('treats a blank storage id as no selection at all', () => {
+    const pipelines = usePipelinesStore()
+    pipelines.addToDraft('coder')
+    pipelines.setDraftBinaryOutput(0, { storageServiceId: '', contextServiceIds: ['inventory'] })
+    expect(pipelines.draftBinaryOutput(0)).toBeUndefined()
+    expect(pipelines.draftStepOptions[0]).toBeNull()
+  })
+
+  it('merges into the options bag rather than clobbering other per-step options', () => {
+    const pipelines = usePipelinesStore()
+    pipelines.addToDraft('coder')
+    pipelines.draftStepOptions[0] = { agentVariantId: 'acme:fast' }
+
+    pipelines.setDraftBinaryOutput(0, { storageServiceId: 'file-storage' })
+    expect(pipelines.draftStepOptions[0]).toEqual({
+      agentVariantId: 'acme:fast',
+      binaryOutput: { storageServiceId: 'file-storage' },
+    })
+
+    pipelines.setDraftBinaryOutput(0, undefined)
+    expect(pipelines.draftStepOptions[0]).toEqual({ agentVariantId: 'acme:fast' })
+  })
+})

package/app/stores/pipelines/draftStepConfig.ts

@@ -1,4 +1,4 @@
-import type { StepOptions } from '@cat-factory/contracts'
+import type { BinaryOutputConfig, StepOptions } from '@cat-factory/contracts'
 import type { ConsensusStepConfig } from '~/types/consensus'
 import { defaultConsensusConfig, type PipelinesContext } from './context'
 
@@ -6,7 +6,8 @@ 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).
+ * (requirements auto-recommendation, the picked skill, the picked agent-kind variant, the
+ * per-step output-token ceiling, the binary-output storage/context selection).
  *
  * 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
@@ -160,6 +161,45 @@ export function createPipelineStepConfigActions(ctx: PipelinesContext) {
     draftStepOptions.value[index] = Object.keys(next).length ? next : null
   }
 
+  /**
+   * 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 next: StepOptions = { ...draftStepOptions.value[index] }
+    if (config?.storageServiceId) {
+      const { storageServiceId, contextServiceIds, generatorIds, modalities } = config
+      next.binaryOutput = {
+        storageServiceId,
+        ...(contextServiceIds?.length ? { contextServiceIds } : {}),
+        ...(generatorIds?.length ? { generatorIds } : {}),
+        ...(modalities?.length ? { modalities } : {}),
+      }
+    } else delete next.binaryOutput
+    draftStepOptions.value[index] = Object.keys(next).length ? next : null
+  }
+
   /**
    * 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).
@@ -197,6 +237,8 @@ export function createPipelineStepConfigActions(ctx: PipelinesContext) {
     setDraftSkillId,
     draftAgentVariantId,
     setDraftAgentVariantId,
+    draftBinaryOutput,
+    setDraftBinaryOutput,
     draftMaxOutputTokens,
     setDraftMaxOutputTokens,
   }

package/app/stores/tutorial.spec.ts

@@ -64,6 +64,81 @@ describe('useTutorialStore launch prompt', () => {
   })
 })
 
+describe('useTutorialStore catalogue', () => {
+  it('opens over the launch prompt without answering it', () => {
+    // Browsing the full list is not "no thanks" — it is the opposite — so the offer must
+    // return next launch if the user browses and starts nothing. And the two are modals:
+    // leaving the prompt open would stack them.
+    const tutorial = useTutorialStore()
+    tutorial.maybeOfferOnLaunch()
+    tutorial.openCatalogue()
+    expect(tutorial.catalogueOpen).toBe(true)
+    expect(tutorial.promptOpen).toBe(false)
+    expect(tutorial.decision).toBeNull()
+  })
+
+  it('closes when a tour starts or resumes from it', () => {
+    const tutorial = useTutorialStore()
+    tutorial.openCatalogue()
+    tutorial.startTour('board-basics')
+    expect(tutorial.catalogueOpen).toBe(false)
+
+    tutorial.setStepIndex(2)
+    tutorial.stopTour()
+    tutorial.openCatalogue()
+    tutorial.resumeTour('board-basics')
+    expect(tutorial.catalogueOpen).toBe(false)
+  })
+
+  it('reports its own window as open, so the coach marks stand down', () => {
+    // The overlay renders at z-[70] to sit ABOVE the app's modals, since a step legitimately
+    // points into one. The catalogue is openable mid-tour (that is what the `continue` action
+    // is for), and there the same z-index would float a ring and a tooltip over the window the
+    // user just opened. The tour itself is untouched — only the marks go.
+    const tutorial = useTutorialStore()
+    tutorial.startTour('board-basics')
+    expect(tutorial.ownWindowOpen).toBe(false)
+
+    tutorial.openCatalogue()
+    expect(tutorial.ownWindowOpen).toBe(true)
+    expect(tutorial.activeTourId).toBe('board-basics')
+
+    tutorial.closeCatalogue()
+    expect(tutorial.ownWindowOpen).toBe(false)
+
+    tutorial.openPrompt()
+    expect(tutorial.ownWindowOpen).toBe(true)
+  })
+
+  it('resets every record of progress, including the answered offer', () => {
+    // What someone handing the app to a colleague is asking for: the first-launch experience
+    // back. Clearing only the completion list would leave the offer answered, so the prompt
+    // they are trying to demo would never appear.
+    const tutorial = useTutorialStore()
+    tutorial.startTour('board-basics')
+    tutorial.completeTour()
+    tutorial.startTour('run-task')
+    tutorial.setStepIndex(2)
+    tutorial.stopTour()
+
+    tutorial.resetProgress()
+    expect(tutorial.completedTourIds).toEqual([])
+    expect(tutorial.interruptedAt('run-task')).toBeNull()
+    expect(tutorial.decision).toBeNull()
+  })
+
+  it('leaves a running tour alone when progress is reset', () => {
+    // A click about history must not end the walkthrough the user is in the middle of —
+    // which would also leave it unrecorded, since nothing marks a stopped tour complete.
+    const tutorial = useTutorialStore()
+    tutorial.startTour('board-basics')
+    tutorial.setStepIndex(2)
+    tutorial.resetProgress()
+    expect(tutorial.activeTourId).toBe('board-basics')
+    expect(tutorial.stepIndex).toBe(2)
+  })
+})
+
 describe('useTutorialStore tours', () => {
   it('starting a tour records acceptance, closes the prompt, and resets the cursor', () => {
     const tutorial = useTutorialStore()