@cat-factory/app 0.145.2 → 0.146.1

package/app/components/environments/EnvSetupStepper.vue

@@ -0,0 +1,70 @@
+<script setup lang="ts">
+// The environment-setup wizard's stepper header, driven entirely by
+// `useJourneyProgress` (modular-react#83, production-feedback item 4). The ordered
+// steps, the live position, and the "Step X of N" total all come from
+// `resolveStepSequence` walking the journey's transition graph — there is no
+// hand-maintained step-order array to keep in sync (the old `ENV_STEP_ORDER` +
+// `crumbState` is gone). Rendered inside `<JourneyHost>`, which hands it the live
+// `instanceId`; each step's label is the i18n key carried in the journey's `steps`
+// metadata.
+import type { InstanceId } from '@modular-vue/journeys'
+import { useJourneyProgress } from '@modular-vue/journeys'
+import { environmentSetupJourney } from '~/modular/journeys/environmentSetup'
+import type { EnvSetupInput } from '~/modular/journeys/environmentSetup.logic'
+
+const props = defineProps<{
+  /** The live journey instance from `<JourneyHost>`, or null before it starts. */
+  instanceId: InstanceId | null
+  /** The launch input; frozen for the host's lifetime, so the resolved spine is
+   *  stable (`useJourneyProgress` reads `sequence.input` once at setup). */
+  input: EnvSetupInput
+}>()
+
+const { t, te } = useI18n()
+
+const { index, total, steps } = useJourneyProgress(
+  () => props.instanceId,
+  environmentSetupJourney,
+  { sequence: { input: props.input } },
+)
+
+/** Resolve a step's progress-label key (from the journey's `steps` metadata)
+ *  through i18n, tolerating a locale that omits it rather than leaking the key. */
+function stepLabel(key: string | undefined): string {
+  return key && te(key) ? t(key) : ''
+}
+</script>
+
+<template>
+  <div class="space-y-2" data-testid="env-setup-stepper">
+    <p v-if="total" class="text-[11px] font-medium text-slate-400" data-testid="env-setup-progress">
+      {{ t('environmentWizard.progress', { index: index + 1, total }) }}
+    </p>
+    <ol class="flex items-center gap-2 text-[11px]">
+      <li
+        v-for="(step, i) in steps"
+        :key="step.entry"
+        class="flex items-center gap-2"
+        :data-testid="`env-setup-crumb-${step.entry}`"
+      >
+        <span
+          class="flex h-5 w-5 items-center justify-center rounded-full text-[10px] font-semibold"
+          :class="{
+            'bg-primary-500 text-white': i === index,
+            'bg-emerald-600/70 text-white': i < index,
+            'bg-slate-700 text-slate-300': i > index,
+          }"
+          >{{ i + 1 }}</span
+        >
+        <span :class="i === index ? 'text-slate-100' : 'text-slate-500'">
+          {{ stepLabel(step.progressLabel) }}
+        </span>
+        <UIcon
+          v-if="i < steps.length - 1"
+          name="i-lucide-chevron-right"
+          class="h-3 w-3 text-slate-600"
+        />
+      </li>
+    </ol>
+  </div>
+</template>

package/app/components/environments/EnvironmentSetupWizard.vue

@@ -8,14 +8,15 @@
 // journey (`~/modular/journeys/environmentSetup`), hosted here by `<JourneyHost>`:
 // it starts the journey on open (RESUMING the in-flight instance for the same
 // frame when one was left mid-flow, via the Pinia persistence adapter), renders
-// the current step through `<JourneyOutlet>`, and abandons it on close. Each step
-// component drives the `environmentWizard` store for its data/actions and fires
-// the journey's exits to advance. On `complete` (the save step's Done) the journey
-// clears its persisted blob and we close the modal.
+// the current step through `<JourneyOutlet>`, and abandons it on close. The
+// stepper header + "Step X of N" are derived from the journey's transition graph
+// by `<EnvSetupStepper>` (via `useJourneyProgress`), not a hand-maintained step
+// list. Each step component drives the `environmentWizard` store for its
+// data/actions and fires the journey's exits to advance. On `complete` (the save
+// step's Done) the journey clears its persisted blob and we close the modal.
 import { computed } from 'vue'
 import { JourneyHost, JourneyOutlet } from '@modular-vue/journeys'
 import { environmentSetupHandle } from '~/modular/journeys/environmentSetup'
-import { ENV_STEP_ORDER, type EnvStep } from '~/modular/journeys/environmentSetup.logic'
 
 const ui = useUiStore()
 const { t } = useI18n()
@@ -30,23 +31,6 @@ const open = computed({
 // Read once at journey start; keyed for resume. Frozen for the host's lifetime,
 // so the modal remounts the host per open (it renders under `v-if` upstream).
 const input = computed(() => ({ frameId: ui.environmentWizardFrameId }))
-
-const STEP_LABEL = computed<Record<EnvStep, string>>(() => ({
-  pick: t('environmentWizard.steps.pick'),
-  review: t('environmentWizard.steps.review'),
-  preflight: t('environmentWizard.steps.preflight'),
-  save: t('environmentWizard.steps.save'),
-}))
-
-/** The crumb index of a step, relative to the current journey step. */
-function crumbState(
-  entry: EnvStep,
-  currentEntry: EnvStep | undefined,
-): 'current' | 'done' | 'todo' {
-  if (!currentEntry) return 'todo'
-  if (entry === currentEntry) return 'current'
-  return ENV_STEP_ORDER.indexOf(entry) < ENV_STEP_ORDER.indexOf(currentEntry) ? 'done' : 'todo'
-}
 </script>
 
 <template>
@@ -63,43 +47,9 @@ function crumbState(
           :input="input"
           @finished="ui.closeEnvironmentSetup()"
         >
-          <template #default="{ instanceId, instance }">
-            <!-- stepper header, driven by the journey's current step -->
-            <ol class="flex items-center gap-2 text-[11px]">
-              <li
-                v-for="(s, i) in ENV_STEP_ORDER"
-                :key="s"
-                class="flex items-center gap-2"
-                :data-testid="`env-setup-crumb-${s}`"
-              >
-                <span
-                  class="flex h-5 w-5 items-center justify-center rounded-full text-[10px] font-semibold"
-                  :class="{
-                    'bg-primary-500 text-white':
-                      crumbState(s, (instance?.step?.entry as EnvStep) ?? undefined) === 'current',
-                    'bg-emerald-600/70 text-white':
-                      crumbState(s, (instance?.step?.entry as EnvStep) ?? undefined) === 'done',
-                    'bg-slate-700 text-slate-300':
-                      crumbState(s, (instance?.step?.entry as EnvStep) ?? undefined) === 'todo',
-                  }"
-                  >{{ i + 1 }}</span
-                >
-                <span
-                  :class="
-                    crumbState(s, (instance?.step?.entry as EnvStep) ?? undefined) === 'current'
-                      ? 'text-slate-100'
-                      : 'text-slate-500'
-                  "
-                >
-                  {{ STEP_LABEL[s] }}
-                </span>
-                <UIcon
-                  v-if="i < ENV_STEP_ORDER.length - 1"
-                  name="i-lucide-chevron-right"
-                  class="h-3 w-3 text-slate-600"
-                />
-              </li>
-            </ol>
+          <template #default="{ instanceId }">
+            <!-- stepper header, derived from the journey graph -->
+            <EnvSetupStepper :instance-id="instanceId" :input="input" />
 
             <!-- the current step (pick / review / preflight / save) -->
             <div class="mt-4">

package/app/components/prReview/PrReviewWindow.vue

@@ -63,6 +63,12 @@ const ITEM_ICON: Record<string, string> = {
 const working = computed(() => status.value === 'fixing' || status.value === 'posting')
 const findings = computed<PrReviewFinding[]>(() => state.value?.findings ?? [])
 
+// The outcome of the last `post` attempt (null until one runs). A partial/failed post re-parks
+// the review at `awaiting_selection` carrying this, so the human sees what posted / what failed
+// and can retry ONLY the posting rather than re-running the whole review.
+const postReport = computed(() => state.value?.postReport ?? null)
+const postedIds = computed(() => new Set(state.value?.postedFindingIds ?? []))
+
 /** Severity → chip classes (styling, not copy). */
 const SEVERITY_CLASS: Record<PrReviewSeverity, string> = {
   blocker: 'bg-rose-500/15 text-rose-300 ring-rose-500/30',
@@ -260,6 +266,57 @@ async function onResolve(action: PrReviewResolution): Promise<void> {
           {{ prReview.error }}
         </p>
 
+        <!-- The outcome of the most recent `post` attempt: how many of how many comments landed,
+             which failed + why, and how many findings were folded into the summary because their
+             line isn't in the PR diff. Surfaced so a partial/failed post is legible + retryable. -->
+        <div
+          v-if="postReport"
+          data-testid="pr-review-post-report"
+          class="mb-3 rounded-lg border px-3 py-2 text-[12px]"
+          :class="
+            postReport.failures.length > 0 || postReport.bodyPosted === false
+              ? 'border-amber-500/40 bg-amber-500/10 text-amber-200'
+              : 'border-emerald-500/40 bg-emerald-500/10 text-emerald-200'
+          "
+        >
+          <div class="mb-1 flex items-center gap-1.5 font-medium">
+            <UIcon
+              :name="
+                postReport.failures.length > 0 || postReport.bodyPosted === false
+                  ? 'i-lucide-alert-triangle'
+                  : 'i-lucide-check-circle-2'
+              "
+              class="h-4 w-4 shrink-0"
+            />
+            <span>{{ t('prReview.postReport.heading') }}</span>
+          </div>
+          <p data-testid="pr-review-post-count">
+            {{
+              t('prReview.postReport.posted', {
+                posted: postReport.posted,
+                attempted: postReport.attempted,
+              })
+            }}
+          </p>
+          <p v-if="postReport.folded > 0" class="mt-0.5 opacity-90">
+            {{ t('prReview.postReport.folded', { count: postReport.folded }) }}
+          </p>
+          <template v-if="postReport.failures.length > 0">
+            <p class="mt-1.5 font-medium">{{ t('prReview.postReport.failuresHeading') }}</p>
+            <ul class="mt-0.5 space-y-0.5" data-testid="pr-review-post-failures">
+              <li v-for="f in postReport.failures" :key="f.findingId" class="flex gap-1.5">
+                <code class="shrink-0 text-amber-100"
+                  >{{ f.path }}<template v-if="f.line != null">:{{ f.line }}</template></code
+                >
+                <span class="opacity-90">— {{ f.reason }}</span>
+              </li>
+            </ul>
+          </template>
+          <p v-if="postReport.bodyPosted === false && postReport.bodyError" class="mt-1.5">
+            {{ t('prReview.postReport.bodyError', { error: postReport.bodyError }) }}
+          </p>
+        </div>
+
         <!-- The reviewer's overall assessment. -->
         <p
           v-if="state?.summary"
@@ -330,6 +387,13 @@ async function onResolve(action: PrReviewResolution): Promise<void> {
                     <span class="rounded bg-slate-800 px-1.5 py-0.5 text-[10px] text-slate-300">
                       {{ t(`prReview.category.${f.category}`) }}
                     </span>
+                    <span
+                      v-if="postedIds.has(f.id)"
+                      data-testid="pr-review-finding-posted"
+                      class="rounded bg-emerald-500/15 px-1.5 py-0.5 text-[10px] font-semibold uppercase text-emerald-300 ring-1 ring-emerald-500/30"
+                    >
+                      {{ t('prReview.postReport.postedBadge') }}
+                    </span>
                     <h4 class="min-w-0 flex-1 text-[13px] font-medium text-slate-100">
                       {{ f.title }}
                     </h4>
@@ -381,7 +445,7 @@ async function onResolve(action: PrReviewResolution): Promise<void> {
         data-testid="pr-review-post"
         @click="onResolve('post')"
       >
-        {{ t('prReview.post') }}
+        {{ postReport ? t('prReview.postReport.retry') : t('prReview.post') }}
       </UButton>
       <UButton
         color="primary"

package/app/modular/journeys/environmentSetup.logic.spec.ts

@@ -1,20 +1,28 @@
 import { describe, expect, it } from 'vitest'
+import { resolveStepSequence } from '@modular-vue/journeys'
 import {
-  ENV_STEP_ORDER,
+  ENV_MODULE_ID,
+  environmentSetupJourney,
   envInitialState,
-  envNextAfter,
   envStartStep,
 } from './environmentSetup.logic'
+import en from '../../../i18n/locales/en.json'
 
-// Pure navigation graph for the environment-setup journey (slice 3). `envNextAfter`
-// is the source of truth the journey's `advance` transitions derive their target
-// entries from (see `environmentSetup.ts`), so pinning the order, start branch, and
-// forward edges here means a wiring regression can't silently reorder or drop a step.
-describe('environment-setup journey logic', () => {
-  it('orders the steps pick → review → preflight → save', () => {
-    expect(ENV_STEP_ORDER).toEqual(['pick', 'review', 'preflight', 'save'])
-  })
+/** Dot-path lookup into the real `en.json`, mirroring which keys actually ship. */
+function hasKey(path: string): boolean {
+  return (
+    path.split('.').reduce<unknown>((node, seg) => {
+      return node && typeof node === 'object' ? (node as Record<string, unknown>)[seg] : undefined
+    }, en) !== undefined
+  )
+}
 
+// Pure navigation graph for the environment-setup journey (slice 3). The step
+// order is derived from the annotated transition graph (production-feedback item
+// 4), so `resolveStepSequenceResult` walking the real journey definition is the
+// guard against a silent reorder or dropped step — no hand-maintained order array
+// to pin separately.
+describe('environment-setup journey logic', () => {
   it('seeds state from the launch input', () => {
     expect(envInitialState({ frameId: 'blk_1' })).toEqual({ frameId: 'blk_1' })
     expect(envInitialState({ frameId: null })).toEqual({ frameId: null })
@@ -25,10 +33,33 @@ describe('environment-setup journey logic', () => {
     expect(envStartStep({ frameId: null }, { frameId: null })).toBe('pick')
   })
 
-  it('advances linearly and terminates after save', () => {
-    expect(envNextAfter('pick')).toBe('review')
-    expect(envNextAfter('review')).toBe('preflight')
-    expect(envNextAfter('preflight')).toBe('save')
-    expect(envNextAfter('save')).toBe('done')
+  it('derives the pick → review → preflight → save order from the transition graph', () => {
+    const steps = resolveStepSequence(environmentSetupJourney, { input: { frameId: null } })
+    expect(steps.map((s) => s.entry)).toEqual(['pick', 'review', 'preflight', 'save'])
+    expect(steps.every((s) => s.module === ENV_MODULE_ID)).toBe(true)
+    expect(steps.map((s) => s.progressLabel)).toEqual([
+      'environmentWizard.steps.pick',
+      'environmentWizard.steps.review',
+      'environmentWizard.steps.preflight',
+      'environmentWizard.steps.save',
+    ])
+  })
+
+  it('starts the derived sequence at review when a frame is preselected', () => {
+    const steps = resolveStepSequence(environmentSetupJourney, { input: { frameId: 'blk_1' } })
+    expect(steps.map((s) => s.entry)).toEqual(['review', 'preflight', 'save'])
+  })
+
+  // The stepper resolves each label through a VARIABLE key (`t(step.progressLabel)`), so
+  // the tier-1 typed-message-keys check + `vue-i18n-extract` can no longer see these keys
+  // as used and can't catch a typo or a dropped key. Pin the missing-key guard here instead:
+  // every `progressLabel` the real definition emits must resolve to a shipping `en.json` key.
+  it('carries a shipping en.json label key for every derived step', () => {
+    const steps = resolveStepSequence(environmentSetupJourney, { input: { frameId: null } })
+    for (const step of steps) {
+      const key = step.progressLabel
+      expect(key, `missing i18n key for step "${step.entry}"`).toBeTruthy()
+      expect(hasKey(key ?? ''), `key "${key}" not in en.json`).toBe(true)
+    }
   })
 })

package/app/modular/journeys/environmentSetup.logic.ts

@@ -10,15 +10,26 @@
  * trial) stay in that Pinia store, which the step components still drive; the
  * journey just decides WHICH step shows and threads the target frame id.
  *
- * This file is deliberately free of Vue/`.vue`/`defineModule` imports so the
- * transition graph is unit-tested directly (`environmentSetup.spec.ts`); the
- * component wiring lives in `environmentSetup.ts`, which feeds these helpers into
- * `defineJourney`'s `transitions` map.
+ * The step ORDER is no longer spelled out a second time as an ordered array: it
+ * is DERIVED from the annotated transition graph below (production-feedback item
+ * 4 in modular-react#83). Each transition wraps its handler with
+ * `defineTransition({ targets, handle })` so the static `targets` declare where
+ * the flow can go; `resolveStepSequence` / `useJourneyProgress` walk that graph
+ * to produce the ordered step list and the wizard's "Step X of N" progress from
+ * the one place the flow is encoded. `steps` carries each step's progress-label
+ * key beside the transitions.
+ *
+ * This definition lives in the logic file (not the SFC-importing
+ * `environmentSetup.ts`) so the graph stays free of `.vue` imports and is
+ * unit-tested directly (`environmentSetup.logic.spec.ts`). It references the step
+ * module only as a TYPE (`import type`), which is erased at runtime, so importing
+ * this file pulls no components. `environmentSetup.ts` supplies the module (with
+ * its step components) and re-exports the journey + the launch handle + the
+ * persistence adapter.
  */
-
-/** The journey's ordered step entries (also the module's `entryPoints` keys). */
-export const ENV_STEP_ORDER = ['pick', 'review', 'preflight', 'save'] as const
-export type EnvStep = (typeof ENV_STEP_ORDER)[number]
+import type { ExitCtx } from '@modular-vue/journeys'
+import { defineJourney, defineTransition } from '@modular-vue/journeys'
+import type { environmentSetupModule } from '~/modular/journeys/environmentSetup'
 
 /** The single module id every step entry lives under. */
 export const ENV_MODULE_ID = 'cat-factory:environment-setup' as const
@@ -52,35 +63,91 @@ export function envInitialState(input: EnvSetupInput): EnvSetupState {
 }
 
 /** First step: skip the picker when the launcher already chose a frame. */
-export function envStartStep(_state: EnvSetupState, input: EnvSetupInput): EnvStep {
+export function envStartStep(_state: EnvSetupState, input: EnvSetupInput): 'pick' | 'review' {
   return input.frameId ? 'review' : 'pick'
 }
 
 /**
- * The step reached by advancing from `from` via its forward exit, or `'done'`
- * when the flow completes. The pick step advances via `select` (a distinct
- * exit); the rest via `advance`. Pure and total over `EnvStep`.
- *
- * This is the SINGLE SOURCE OF TRUTH for the linear forward chain: the journey
- * definition (`environmentSetup.ts`) derives its `advance` transitions' target
- * entries from it, so pinning this function in `environmentSetup.logic.spec.ts`
- * genuinely guards the wired graph against a silent reorder/drop. The overloads
- * narrow the return to a concrete entry (or `'done'`) so a transition handler can
- * feed the result straight into a `StepSpec` without a widened `EnvStep | 'done'`.
+ * The journey's module type map — one module, referenced by its `typeof` so the
+ * transition + step maps resolve its literal entry/exit vocabulary with no casts.
+ * This is the case production-feedback item 3 (modular-react#83) fixed: before it,
+ * `defineModule` widened the descriptor, so `typeof environmentSetupModule` could
+ * not stand in as a `TModules` member without re-declaring the entry names by hand.
  */
-export function envNextAfter(from: 'pick'): 'review'
-export function envNextAfter(from: 'review'): 'preflight'
-export function envNextAfter(from: 'preflight'): 'save'
-export function envNextAfter(from: 'save'): 'done'
-export function envNextAfter(from: EnvStep): EnvStep | 'done' {
-  switch (from) {
-    case 'pick':
-      return 'review'
-    case 'review':
-      return 'preflight'
-    case 'preflight':
-      return 'save'
-    case 'save':
-      return 'done'
-  }
-}
+export type EnvModules = { [ENV_MODULE_ID]: typeof environmentSetupModule }
+
+/** Binder threading the journey generics into each annotated transition handler. */
+const transition = defineTransition<EnvModules, EnvSetupState>()
+
+/**
+ * The journey definition. `start` skips the picker when a frame was preselected.
+ * The forward chain is the annotated transitions' `targets`: pick →(select)→
+ * review →(advance)→ preflight →(advance)→ save →(advance)→ complete. Back
+ * navigation is handled by the entries' `allowBack` (declared on the module in
+ * `environmentSetup.ts`), not explicit transitions.
+ */
+export const environmentSetupJourney = defineJourney<EnvModules, EnvSetupState>()({
+  id: 'environment-setup',
+  version: '1.0.0',
+  initialState: (input: EnvSetupInput) => envInitialState(input),
+  start: (state, input: EnvSetupInput) =>
+    envStartStep(state, input) === 'review'
+      ? { module: ENV_MODULE_ID, entry: 'review', input: { frameId: state.frameId } }
+      : { module: ENV_MODULE_ID, entry: 'pick', input: { frameId: state.frameId } },
+  steps: {
+    [ENV_MODULE_ID]: {
+      pick: { progressLabel: 'environmentWizard.steps.pick' },
+      review: { progressLabel: 'environmentWizard.steps.review' },
+      preflight: { progressLabel: 'environmentWizard.steps.preflight' },
+      save: { progressLabel: 'environmentWizard.steps.save' },
+    },
+  },
+  transitions: {
+    [ENV_MODULE_ID]: {
+      pick: {
+        [ENV_SELECT_EXIT]: transition({
+          targets: [{ module: ENV_MODULE_ID, entry: 'review' }],
+          handle: (ctx: ExitCtx<EnvSetupState, EnvSelectOutput, unknown>) => ({
+            next: {
+              module: ENV_MODULE_ID,
+              entry: 'review',
+              input: { frameId: ctx.output.frameId },
+            },
+            state: { frameId: ctx.output.frameId },
+          }),
+        }),
+      },
+      review: {
+        [ENV_ADVANCE_EXIT]: transition({
+          targets: [{ module: ENV_MODULE_ID, entry: 'preflight' }],
+          handle: (ctx) => ({
+            next: {
+              module: ENV_MODULE_ID,
+              entry: 'preflight',
+              input: { frameId: ctx.state.frameId },
+            },
+          }),
+        }),
+      },
+      preflight: {
+        [ENV_ADVANCE_EXIT]: transition({
+          targets: [{ module: ENV_MODULE_ID, entry: 'save' }],
+          handle: (ctx) => ({
+            next: {
+              module: ENV_MODULE_ID,
+              entry: 'save',
+              input: { frameId: ctx.state.frameId },
+            },
+          }),
+        }),
+      },
+      // `save` advances to journey completion.
+      save: {
+        [ENV_ADVANCE_EXIT]: transition({
+          targets: ['complete'],
+          handle: () => ({ complete: undefined }),
+        }),
+      },
+    },
+  },
+})

package/app/modular/journeys/environmentSetup.ts

@@ -1,6 +1,6 @@
 import { defineModule } from '@modular-vue/core'
 import { defineExit } from '@modular-frontend/core'
-import { defineJourney, defineJourneyHandle } from '@modular-vue/journeys'
+import { defineJourneyHandle } from '@modular-vue/journeys'
 import EnvPickStep from '~/components/environments/steps/EnvPickStep.vue'
 import EnvReviewStep from '~/components/environments/steps/EnvReviewStep.vue'
 import EnvPreflightStep from '~/components/environments/steps/EnvPreflightStep.vue'
@@ -13,9 +13,7 @@ import {
   type EnvSelectOutput,
   type EnvSetupInput,
   type EnvSetupState,
-  envInitialState,
-  envNextAfter,
-  envStartStep,
+  environmentSetupJourney,
 } from '~/modular/journeys/environmentSetup.logic'
 
 /**
@@ -25,6 +23,13 @@ import {
  * with a typed, back/rewind-capable, resumable journey; the per-step data + async
  * actions stay in that Pinia store, driven by the step components below.
  *
+ * This file supplies the step MODULE (it imports the step `.vue` components, so —
+ * like `result-views.ts` — it's registered from the client plugin, keeping the
+ * unit-tested `registry.ts` / `*.logic.ts` import graph free of SFCs) and re-exports
+ * the JOURNEY, whose transition graph + step metadata live in the SFC-free
+ * `environmentSetup.logic.ts` (so `resolveStepSequence` / `useJourneyProgress` and
+ * the ordering test have no `.vue` dependency).
+ *
  * Authoring notes (co-evolution): `defineModule` comes from the `@modular-vue/core`
  * binding, but the exit helper `defineExit` is only exported from the neutral
  * `@modular-frontend/core` engine (a direct dep) — the Vue binding doesn't re-export
@@ -36,10 +41,6 @@ import {
  * pick step and never changes mid-flow, so the snapshot input a transition places is
  * always current — even on `preserve-state` back-navigation — which keeps the module
  * type simple (no `buildInput`-optionality quirk) and the flow fully explicit.
- *
- * This file imports the step `.vue` components, so — like `result-views.ts` — it's
- * registered from the client plugin, keeping the unit-tested `registry.ts` /
- * `*.logic.ts` import graph free of SFCs.
  */
 
 /**
@@ -52,20 +53,20 @@ export const environmentSetupModule = defineModule({
   id: ENV_MODULE_ID,
   version: '1.0.0',
   entryPoints: {
-    pick: { mountKinds: ['journey'] as const, component: EnvPickStep },
+    pick: { mountKinds: ['journey'], component: EnvPickStep },
     review: {
-      mountKinds: ['journey'] as const,
-      allowBack: 'preserve-state' as const,
+      mountKinds: ['journey'],
+      allowBack: 'preserve-state',
       component: EnvReviewStep,
     },
     preflight: {
-      mountKinds: ['journey'] as const,
-      allowBack: 'preserve-state' as const,
+      mountKinds: ['journey'],
+      allowBack: 'preserve-state',
       component: EnvPreflightStep,
     },
     save: {
-      mountKinds: ['journey'] as const,
-      allowBack: 'preserve-state' as const,
+      mountKinds: ['journey'],
+      allowBack: 'preserve-state',
       component: EnvSaveStep,
     },
   },
@@ -75,59 +76,7 @@ export const environmentSetupModule = defineModule({
   },
 })
 
-type EnvModules = { [ENV_MODULE_ID]: typeof environmentSetupModule }
-
-/**
- * The journey definition. `start` skips the picker when a frame was preselected;
- * transitions are the linear pick → review → preflight → save chain, terminating
- * with `complete` off the save step's `advance`. Back-navigation is handled by the
- * entries' `allowBack`, not explicit transitions.
- */
-export const environmentSetupJourney = defineJourney<EnvModules, EnvSetupState>()({
-  id: 'environment-setup',
-  version: '1.0.0',
-  initialState: (input: EnvSetupInput) => envInitialState(input),
-  start: (state, input: EnvSetupInput) =>
-    envStartStep(state, input) === 'review'
-      ? ({ module: ENV_MODULE_ID, entry: 'review', input: { frameId: state.frameId } } as const)
-      : ({ module: ENV_MODULE_ID, entry: 'pick', input: { frameId: state.frameId } } as const),
-  transitions: {
-    [ENV_MODULE_ID]: {
-      pick: {
-        [ENV_SELECT_EXIT]: (ctx) => ({
-          next: {
-            module: ENV_MODULE_ID,
-            entry: 'review',
-            input: { frameId: ctx.output.frameId },
-          } as const,
-          state: { frameId: ctx.output.frameId },
-        }),
-      },
-      review: {
-        [ENV_ADVANCE_EXIT]: (ctx) => ({
-          next: {
-            module: ENV_MODULE_ID,
-            entry: envNextAfter('review'),
-            input: { frameId: ctx.state.frameId },
-          } as const,
-        }),
-      },
-      preflight: {
-        [ENV_ADVANCE_EXIT]: (ctx) => ({
-          next: {
-            module: ENV_MODULE_ID,
-            entry: envNextAfter('preflight'),
-            input: { frameId: ctx.state.frameId },
-          } as const,
-        }),
-      },
-      // `save` advances to `envNextAfter('save') === 'done'`, i.e. journey completion.
-      save: {
-        [ENV_ADVANCE_EXIT]: () => ({ complete: undefined }),
-      },
-    },
-  },
-})
+export { environmentSetupJourney }
 
 /** Typed launch handle — callers `runtime.start(handle, { frameId })`. */
 export const environmentSetupHandle = defineJourneyHandle(environmentSetupJourney)

package/app/types/execution.ts

@@ -49,6 +49,8 @@ export type {
   PrReviewSeverity,
   PrReviewCategory,
   PrReviewResolution,
+  PrReviewPostReport,
+  PrReviewPostFailure,
   GateFailingCheck,
   GateAttempt,
   GateStepState,

package/i18n/locales/de.json

@@ -4808,6 +4808,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Schritt {index} von {total}",
     "title": "Eine Testumgebung einrichten",
     "subtitle": "Erkenne, prüfe und speichere ein Docker-Compose-Rezept, damit der Deployer es bereitstellt.",
     "recommended": "empfohlen",
@@ -4953,6 +4954,15 @@
       "title": "Review-Kommentare werden gepostet…",
       "hint": "Die ausgewählten Befunde werden als Inline-Kommentare im Pull Request veröffentlicht."
     },
+    "postReport": {
+      "heading": "Ergebnis der Veröffentlichung",
+      "posted": "{posted} von {attempted} Kommentaren veröffentlicht",
+      "folded": "Zur Zusammenfassung hinzugefügt (keine Zeile im Diff zum Verankern): {count}",
+      "failuresHeading": "Diese Kommentare konnten nicht veröffentlicht werden:",
+      "bodyError": "Der Zusammenfassungskommentar konnte nicht veröffentlicht werden: {error}",
+      "postedBadge": "Veröffentlicht",
+      "retry": "Erneut veröffentlichen"
+    },
     "severity": {
       "blocker": "Blocker",
       "high": "Hoch",

package/i18n/locales/en.json

@@ -4941,6 +4941,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Step {index} of {total}",
     "title": "Set up a test environment",
     "subtitle": "Detect, review, and save a Docker Compose recipe so the Deployer provisions it.",
     "recommended": "recommended",
@@ -5082,6 +5083,15 @@
       "title": "Posting review comments…",
       "hint": "Publishing the selected findings as inline comments on the pull request."
     },
+    "postReport": {
+      "heading": "Posting result",
+      "posted": "{posted} of {attempted} comments posted",
+      "folded": "Added to the summary (no in-diff line to anchor to): {count}",
+      "failuresHeading": "Could not post these comments:",
+      "bodyError": "The summary comment failed to post: {error}",
+      "postedBadge": "Posted",
+      "retry": "Retry posting"
+    },
     "severity": {
       "blocker": "Blocker",
       "high": "High",

package/i18n/locales/es.json

@@ -4800,6 +4800,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Paso {index} de {total}",
     "title": "Configurar un entorno de pruebas",
     "subtitle": "Detecta, revisa y guarda una receta de Docker Compose para que el Deployer la aprovisione.",
     "recommended": "recomendado",
@@ -4941,6 +4942,15 @@
       "title": "Publicando comentarios de revisión…",
       "hint": "Publicando los hallazgos seleccionados como comentarios en línea en el pull request."
     },
+    "postReport": {
+      "heading": "Resultado de la publicación",
+      "posted": "{posted} de {attempted} comentarios publicados",
+      "folded": "Añadidos al resumen (sin línea en el diff donde anclar): {count}",
+      "failuresHeading": "No se pudieron publicar estos comentarios:",
+      "bodyError": "No se pudo publicar el comentario de resumen: {error}",
+      "postedBadge": "Publicado",
+      "retry": "Reintentar publicación"
+    },
     "severity": {
       "blocker": "Bloqueante",
       "high": "Alta",

package/i18n/locales/fr.json

@@ -4800,6 +4800,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Étape {index} sur {total}",
     "title": "Configurer un environnement de test",
     "subtitle": "Détectez, vérifiez et enregistrez une recette Docker Compose pour que le Deployer la provisionne.",
     "recommended": "recommandé",
@@ -4941,6 +4942,15 @@
       "title": "Publication des commentaires de revue…",
       "hint": "Publication des points sélectionnés en commentaires en ligne sur la pull request."
     },
+    "postReport": {
+      "heading": "Résultat de la publication",
+      "posted": "{posted} commentaires sur {attempted} publiés",
+      "folded": "Ajoutés au résumé (aucune ligne du diff où les ancrer) : {count}",
+      "failuresHeading": "Impossible de publier ces commentaires :",
+      "bodyError": "Le commentaire de synthèse n'a pas pu être publié : {error}",
+      "postedBadge": "Publié",
+      "retry": "Réessayer la publication"
+    },
     "severity": {
       "blocker": "Bloquant",
       "high": "Élevée",

package/i18n/locales/he.json

@@ -4811,6 +4811,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "שלב {index} מתוך {total}",
     "title": "הגדרת סביבת בדיקות",
     "subtitle": "זהו, סקרו ושמרו מתכון Docker Compose כדי שה-Deployer יקצה אותו.",
     "recommended": "מומלץ",
@@ -4952,6 +4953,15 @@
       "title": "מפרסם הערות בדיקה…",
       "hint": "מפרסם את הממצאים שנבחרו כהערות מוטבעות בבקשת המשיכה."
     },
+    "postReport": {
+      "heading": "תוצאת הפרסום",
+      "posted": "פורסמו {posted} מתוך {attempted} הערות",
+      "folded": "נוספו לסיכום (אין שורה ב-diff לעגן אליה): {count}",
+      "failuresHeading": "לא ניתן היה לפרסם את ההערות הבאות:",
+      "bodyError": "לא ניתן היה לפרסם את הערת הסיכום: {error}",
+      "postedBadge": "פורסם",
+      "retry": "נסה לפרסם שוב"
+    },
     "severity": {
       "blocker": "חוסם",
       "high": "גבוה",

package/i18n/locales/it.json

@@ -4808,6 +4808,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Passaggio {index} di {total}",
     "title": "Configura un ambiente di test",
     "subtitle": "Rileva, rivedi e salva una ricetta Docker Compose in modo che il Deployer la esegua.",
     "recommended": "consigliato",
@@ -4953,6 +4954,15 @@
       "title": "Pubblicazione dei commenti di revisione…",
       "hint": "Pubblicazione dei rilievi selezionati come commenti inline sulla pull request."
     },
+    "postReport": {
+      "heading": "Esito della pubblicazione",
+      "posted": "{posted} di {attempted} commenti pubblicati",
+      "folded": "Aggiunti al riepilogo (nessuna riga nel diff a cui ancorarli): {count}",
+      "failuresHeading": "Impossibile pubblicare questi commenti:",
+      "bodyError": "Impossibile pubblicare il commento di riepilogo: {error}",
+      "postedBadge": "Pubblicato",
+      "retry": "Riprova la pubblicazione"
+    },
     "severity": {
       "blocker": "Bloccante",
       "high": "Alta",

package/i18n/locales/ja.json

@@ -4812,6 +4812,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "ステップ {index} / {total}",
     "title": "テスト環境をセットアップ",
     "subtitle": "Docker Compose レシピを検出・確認・保存して、Deployer がプロビジョニングできるようにします。",
     "recommended": "推奨",
@@ -4953,6 +4954,15 @@
       "title": "レビューコメントを投稿中…",
       "hint": "選択した指摘をプルリクエストのインラインコメントとして公開しています。"
     },
+    "postReport": {
+      "heading": "投稿結果",
+      "posted": "{attempted} 件中 {posted} 件のコメントを投稿しました",
+      "folded": "差分に対応する行がないため要約に追加: {count}",
+      "failuresHeading": "次のコメントを投稿できませんでした:",
+      "bodyError": "要約コメントを投稿できませんでした: {error}",
+      "postedBadge": "投稿済み",
+      "retry": "投稿を再試行"
+    },
     "severity": {
       "blocker": "ブロッカー",
       "high": "高",

package/i18n/locales/pl.json

@@ -4800,6 +4800,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Krok {index} z {total}",
     "title": "Skonfiguruj środowisko testowe",
     "subtitle": "Wykryj, przejrzyj i zapisz przepis Docker Compose, aby Deployer go udostępnił.",
     "recommended": "zalecane",
@@ -4941,6 +4942,15 @@
       "title": "Publikowanie komentarzy przeglądu…",
       "hint": "Publikowanie wybranych uwag jako komentarzy w treści pull requesta."
     },
+    "postReport": {
+      "heading": "Wynik publikacji",
+      "posted": "Opublikowano {posted} z {attempted} komentarzy",
+      "folded": "Dodano do podsumowania (brak wiersza w różnicy do zakotwiczenia): {count}",
+      "failuresHeading": "Nie udało się opublikować tych komentarzy:",
+      "bodyError": "Nie udało się opublikować komentarza podsumowującego: {error}",
+      "postedBadge": "Opublikowano",
+      "retry": "Ponów publikację"
+    },
     "severity": {
       "blocker": "Blokujące",
       "high": "Wysokie",

package/i18n/locales/tr.json

@@ -4812,6 +4812,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Adım {index} / {total}",
     "title": "Bir test ortamı kur",
     "subtitle": "Deployer sağlasın diye bir Docker Compose tarifini algıla, gözden geçir ve kaydet.",
     "recommended": "önerilen",
@@ -4953,6 +4954,15 @@
       "title": "İnceleme yorumları gönderiliyor…",
       "hint": "Seçili bulgular pull request üzerinde satır içi yorum olarak yayımlanıyor."
     },
+    "postReport": {
+      "heading": "Gönderim sonucu",
+      "posted": "{attempted} yorumdan {posted} tanesi gönderildi",
+      "folded": "Özete eklendi (diff'te tutturulacak satır yok): {count}",
+      "failuresHeading": "Bu yorumlar gönderilemedi:",
+      "bodyError": "Özet yorumu gönderilemedi: {error}",
+      "postedBadge": "Gönderildi",
+      "retry": "Gönderimi yeniden dene"
+    },
     "severity": {
       "blocker": "Engelleyici",
       "high": "Yüksek",

package/i18n/locales/uk.json

@@ -4800,6 +4800,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Крок {index} з {total}",
     "title": "Налаштувати тестове середовище",
     "subtitle": "Виявіть, перегляньте та збережіть рецепт Docker Compose, щоб Deployer його забезпечив.",
     "recommended": "рекомендовано",
@@ -4941,6 +4942,15 @@
       "title": "Публікація коментарів огляду…",
       "hint": "Публікація вибраних зауважень як вбудованих коментарів у pull request."
     },
+    "postReport": {
+      "heading": "Результат публікації",
+      "posted": "Опубліковано {posted} з {attempted} коментарів",
+      "folded": "Додано до підсумку (немає рядка в різниці для прив'язки): {count}",
+      "failuresHeading": "Не вдалося опублікувати ці коментарі:",
+      "bodyError": "Не вдалося опублікувати підсумковий коментар: {error}",
+      "postedBadge": "Опубліковано",
+      "retry": "Повторити публікацію"
+    },
     "severity": {
       "blocker": "Блокер",
       "high": "Високий",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.145.2",
+  "version": "0.146.1",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -18,9 +18,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@modular-frontend/core": "^0.5.0",
-    "@modular-vue/core": "^1.4.0",
-    "@modular-vue/journeys": "^1.3.0",
+    "@modular-frontend/core": "^0.6.0",
+    "@modular-vue/core": "^1.5.0",
+    "@modular-vue/journeys": "^1.4.0",
     "@modular-vue/nuxt": "^0.4.0",
     "@modular-vue/runtime": "^1.4.1",
     "@modular-vue/vue": "^1.4.0",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.152.1"
+    "@cat-factory/contracts": "0.152.2"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",