@cat-factory/app 0.195.0 → 0.195.1

package/app/components/initiative/InitiativePlanDecision.vue

@@ -0,0 +1,134 @@
+<script setup lang="ts">
+// The plan gate's DECISION half: the overall-feedback field plus the two commands that resolve the
+// park — accept the plan, or send it back to the planner.
+//
+// It is its own component because the gate has two surfaces: the full document review
+// (`InitiativePlanReview`, which owns the tracker window while a rendered plan is parked) and the
+// compact notice a gate with no rendered plan falls back to (`InitiativePlanNotice`). Both must
+// word the commands identically, gate them on the same RBAC fact, and refuse an empty send-back
+// the same way — so the state machine and its markup live here once rather than in each.
+//
+// Deliberately NOT offered: "approve with corrections". The plan was ingested into the
+// `initiatives` entity before this gate was raised, so the document is a VIEW of committed state —
+// an edit typed over it would reach nothing, and the engine refuses it outright
+// (`outputIsRendered` → 422). Requesting changes is the route for a correction, which is why an
+// anchored comment is worth having: it quotes the planner's own text back to it on the re-plan.
+import { computed, ref, watch } from 'vue'
+import type { RequestStepChangesInput } from '@cat-factory/contracts'
+
+const props = defineProps<{
+  /** The parked gate being resolved. */
+  approvalId: string
+  /** The run the gate belongs to, for the approve / request-changes commands. */
+  instanceId: string
+  /** Whether the viewer may resolve runs at all (RBAC); false renders the actions disabled. */
+  canExecute: boolean
+  /**
+   * The anchored per-block comments to send with a send-back, from the surface that offers
+   * commenting. Absent on the notice surface, which has no document to anchor to.
+   */
+  comments?: RequestStepChangesInput['comments']
+}>()
+
+/** A send-back succeeded: the surface drops its anchored drafts (the feedback is cleared here). */
+const emit = defineEmits<{ sent: [] }>()
+
+const execution = useExecutionStore()
+const { t } = useI18n()
+
+const feedback = ref('')
+const submitting = ref(false)
+
+/** Changes can only be requested with something to act on — an empty send would re-plan blind. */
+const canRequestChanges = computed(
+  () => !!feedback.value.trim() || (props.comments?.length ?? 0) > 0,
+)
+
+/** A fresh gate (a re-plan parked again) reviews the new plan clean, drafts dropped. */
+watch(
+  () => props.approvalId,
+  () => {
+    feedback.value = ''
+  },
+)
+
+/**
+ * Accept the plan: the run advances to the committer, which persists it and arms the execution
+ * loop. The window stays open — the review disappears with the approval (live) and the tracker it
+ * gives the window back to is where the plan then executes.
+ */
+async function approve() {
+  if (submitting.value || !props.canExecute) return
+  submitting.value = true
+  try {
+    await execution.approveStep(props.instanceId, props.approvalId)
+  } finally {
+    submitting.value = false
+  }
+}
+
+/** Send the plan back: the planner re-plans from the feedback + the anchored comments. */
+async function requestChanges() {
+  if (submitting.value || !canRequestChanges.value || !props.canExecute) return
+  submitting.value = true
+  try {
+    const ok = await execution.requestStepChanges(props.instanceId, props.approvalId, {
+      feedback: feedback.value.trim() || undefined,
+      comments: props.comments,
+    })
+    if (ok) {
+      feedback.value = ''
+      emit('sent')
+    }
+  } finally {
+    submitting.value = false
+  }
+}
+
+const disabledTitle = computed(() => (props.canExecute ? undefined : t('access.noRunExecute')))
+</script>
+
+<template>
+  <div>
+    <UTextarea
+      v-model="feedback"
+      data-testid="initiative-plan-feedback"
+      :rows="2"
+      autoresize
+      size="sm"
+      class="w-full"
+      :placeholder="t('initiative.planReview.feedbackPlaceholder')"
+    />
+    <div class="mt-2 flex flex-wrap items-center gap-2">
+      <UButton
+        color="primary"
+        size="xs"
+        icon="i-lucide-check"
+        data-testid="initiative-plan-approve"
+        :loading="submitting"
+        :disabled="!canExecute"
+        :title="disabledTitle"
+        @click="approve"
+      >
+        {{ t('initiative.planReview.approve') }}
+      </UButton>
+      <UButton
+        color="warning"
+        variant="soft"
+        size="xs"
+        icon="i-lucide-rotate-ccw"
+        data-testid="initiative-plan-send-back"
+        :loading="submitting"
+        :disabled="!canRequestChanges || !canExecute"
+        :title="
+          canExecute && !canRequestChanges
+            ? t('initiative.planReview.needsFeedback')
+            : disabledTitle
+        "
+        @click="requestChanges"
+      >
+        {{ t('initiative.planReview.sendBack') }}
+      </UButton>
+    </div>
+  </div>
+</template>

package/app/components/initiative/InitiativePlanNotice.vue

@@ -0,0 +1,69 @@
+<script setup lang="ts">
+// The plan gate with NO document to review: the compact rail that sits above the tracker's own
+// sections, states that there is nothing to navigate, and still resolves the park.
+//
+// It is NOT a legacy shim for gates parked before the engine rendered plans. `outputIsRendered` is a
+// fact about the STEP, and a plan gate can park without it today: the planner's post-completion
+// resolver authors the rendering only once it has INGESTED the plan, so a run that reaches the gate
+// without an ingest parks on the planner's transcript summary instead — a perfectly non-empty string
+// that `planReviewDocument` correctly reads as no document (dressing one sentence up under a table
+// of contents is the failure the whole review surface exists to end). Without this surface such a
+// gate would have no resolving surface at all, which is the exact bug the plan-review e2e spec was
+// written for.
+//
+// So it is deliberately NOT a takeover: unlike `InitiativePlanReview`, which replaces the tracker
+// because the document repeats it, this one wants the tracker underneath — there the sections ARE
+// the only rendering of the plan there is. Which is why it has to be TOLD whether they are actually
+// on screen: it renders above the entity branch, because a gate can be parked while the entity is
+// still loading, and pointing a reviewer at sections the window is not showing is worse than saying
+// nothing.
+import type { StepApproval } from '~/types/execution'
+import InitiativePlanDecision from '~/components/initiative/InitiativePlanDecision.vue'
+
+defineProps<{
+  /** The parked gate. */
+  approval: StepApproval
+  /** The run the gate belongs to, for the approve / request-changes commands. */
+  instanceId: string
+  /** Whether the viewer may resolve runs at all (RBAC); false renders the actions disabled. */
+  canExecute: boolean
+  /**
+   * Whether the tracker's own goal / phases / policy sections are rendered below this notice — i.e.
+   * whether the initiative entity has loaded. Only then may the notice point at them as the plan.
+   */
+  hasSections: boolean
+}>()
+
+const { t } = useI18n()
+</script>
+
+<template>
+  <section
+    class="mb-4 rounded-lg border border-amber-500/40 bg-amber-500/10 p-3.5"
+    data-testid="initiative-plan-notice"
+  >
+    <header class="flex items-start gap-2.5">
+      <UIcon name="i-lucide-clipboard-check" class="mt-0.5 h-4 w-4 shrink-0 text-amber-300" />
+      <div class="min-w-0 flex-1">
+        <h3 class="text-[13px] font-semibold text-amber-200">
+          {{ t('initiative.planReview.title') }}
+        </h3>
+        <p class="mt-0.5 text-[12px] leading-relaxed text-amber-100/80">
+          {{ t('initiative.planReview.body') }}
+        </p>
+        <p class="mt-2 text-[12px] leading-relaxed text-amber-100/70">
+          {{ t('initiative.planReview.noDocument') }}
+          <template v-if="hasSections">
+            {{ t('initiative.planReview.noDocumentSections') }}
+          </template>
+        </p>
+      </div>
+    </header>
+    <InitiativePlanDecision
+      class="mt-3"
+      :approval-id="approval.id"
+      :instance-id="instanceId"
+      :can-execute="canExecute"
+    />
+  </section>
+</template>

package/app/components/initiative/InitiativePlanReview.vue

@@ -1,79 +1,76 @@
 <script setup lang="ts">
-// The planner's human gate, reviewed on the PLAN — the tracker window's plan-approval rail.
+// The planner's human gate, reviewed on the PLAN — the surface the tracker window hands its WHOLE
+// body to while a rendered plan is parked.
 //
-// The rail this replaces could approve or send back, but it judged nothing: the plan was a wall
-// of structured sections above it, with no way to navigate a long one and no way to say WHICH
-// part needed changing. So it renders the plan as the document it is — the engine puts a markdown
+// The rail this replaces could approve or send back, but it judged nothing: the plan was a wall of
+// structured sections above it, with no way to navigate a long one and no way to say WHICH part
+// needed changing. So it renders the plan as the document it is — the engine puts a markdown
 // rendering of the INGESTED plan on the gate's proposal (`renderInitiativePlanForReview`, authored
-// by the planner's step resolver, which is the only thing that knows what ingest committed) — and
-// gives it the same three tools the step reader gives the architect's prose: an outline to
-// navigate by, click-to-comment on any block, and overall feedback. Everything here is shared with
-// that reader rather than re-implemented: `useStepProse` for the outline/collapse/scroll-spy,
-// `useProseComments` for the anchoring, and the global `.reader-prose` sheet for the presentation,
-// so the surfaces cannot drift.
+// by the planner's step resolver, the only thing that knows what ingest committed) — and gives it
+// the same three tools the step reader gives the architect's prose: an outline to navigate by,
+// click-to-comment on any block, and overall feedback.
 //
-// Deliberately NOT offered here: "approve with corrections". The plan was ingested into the
-// `initiatives` entity before this gate was raised, so the document is a VIEW of committed state
-// — an edit typed over it would reach nothing, and the engine refuses it outright
-// (`outputIsRendered` → 422). Requesting changes is the route for a correction, which is why a
-// comment is worth anchoring: it quotes the planner's own text back to it on the re-plan.
-import { computed, ref, watch } from 'vue'
+// The LAYOUT is the step reader's too, and for the same reasons (`AgentStepDetail.vue`). The first
+// cut of this surface was a card INSIDE the tracker's scrolling column: outline and document split
+// that column's width between them, the document capped at a 20rem window, and the tracker's own
+// goal / phases / policy / logs sections — the very same plan, since the render reads the ingested
+// entity — repeated underneath. Reviewers scrolled a letterbox while a second copy of what they
+// were reading sat below it. Now the outline is a sidebar OUTSIDE the document, the document takes
+// the full height of the window, the commands sit in an end-side rail, and the duplicate is gone
+// because the window renders this INSTEAD of the tracker while the gate is parked (the tracker's
+// remaining panels — PR links, curation, checkpoints, follow-ups — are all execution-time state
+// that cannot exist yet at plan time).
+//
+// Everything under the layout is shared with that reader rather than re-implemented: `useStepProse`
+// for the outline/collapse/scroll-spy, `useProseComments` for the anchoring, `InitiativePlanDecision`
+// for the two commands, and the global `.reader-prose` sheet for the presentation — so the surfaces
+// cannot drift.
+import { ref, watch } from 'vue'
 import type { StepApproval } from '~/types/execution'
 import { useStepProse } from '~/composables/useStepProse'
 import { useProseComments } from '~/composables/useProseComments'
+import InitiativePlanDecision from '~/components/initiative/InitiativePlanDecision.vue'
 
 const props = defineProps<{
-  /** The parked gate: its `proposal` is the rendered plan document under review. */
+  /** The parked gate under review. */
   approval: StepApproval
   /** The run the gate belongs to, for the approve / request-changes commands. */
   instanceId: string
   /** Whether the viewer may resolve runs at all (RBAC); false renders the actions disabled. */
   canExecute: boolean
   /**
-   * Whether the proposal IS the plan rendering (the step's `outputIsRendered`). Read rather
-   * than inferred from the proposal being non-empty: a run planned before the engine rendered
-   * plans parks on the planner's transcript summary, which is a perfectly non-empty string —
-   * so an emptiness check would show that one sentence under a table of contents as if it were
-   * the plan, which is the failure this whole surface exists to end.
+   * The rendered plan under review, resolved by the host through `planReviewDocument` — the same
+   * value that decided to mount THIS surface rather than the notice, so it is non-empty here.
    */
-  outputIsRendered: boolean
+  planDocument: string
 }>()
 
-const execution = useExecutionStore()
 const { t } = useI18n()
 
-/**
- * The plan document under review — the gate's proposal, but ONLY once the step says that
- * proposal is the plan rendering. Not named `document`: that shadows the global in a template
- * expression. Anything else (a run planned before the engine rendered plans, which parks on the
- * planner's transcript summary) reads as no document, and the `noDocument` notice says so rather
- * than dressing a stray sentence up as the plan.
- */
-const planDocument = computed(() => (props.outputIsRendered ? (props.approval.proposal ?? '') : ''))
-
-// The outline + collapse + scroll-spy, exactly as the step reader resolves them — minus its
-// lead anchor: the reader renders a details card ahead of the prose and this rail renders the
-// document alone, and the spy stops at the first anchor it cannot measure.
-const prose = useStepProse(() => planDocument.value, { leadAnchorId: null })
+// The outline + collapse + scroll-spy, exactly as the step reader resolves them — minus its lead
+// anchor: the reader renders a details card ahead of the prose, while here the run details sit in
+// the sidebar (never scrolled past), and the spy stops at the first anchor it cannot measure.
+const prose = useStepProse(() => props.planDocument, { leadAnchorId: null })
 const {
   outline,
   tocSections,
-  hasOutput,
   collapsed,
   activeId,
-  // The reader's own scroll container, bound straight through so the shared scroll-spy and the
-  // comment-highlight sync read the same element the template scrolls.
+  // The scroll container, bound straight through so the shared scroll-spy and the comment-highlight
+  // sync read the same element the template scrolls.
   scrollEl,
   sectionEls,
   toggle,
+  setAll,
+  allCollapsed,
   goTo,
   onScroll,
 } = prose
 
 /**
- * Per-block comment drafts over the plan, anchored to its source lines. Commenting follows the
- * same RBAC gate as the actions: a viewer who cannot resolve the run cannot send the comments
- * anywhere, so offering the composer would only invite work the Send-back button then refuses.
+ * Per-block comment drafts over the plan, anchored to its source lines. Commenting follows the same
+ * RBAC gate as the commands: a viewer who cannot resolve the run cannot send the comments anywhere,
+ * so offering the composer would only invite work the Send-back button then refuses.
  */
 const {
   comments: planComments,
@@ -86,266 +83,293 @@ const {
   removeComment,
   reset: resetComments,
 } = useProseComments({
-  output: () => planDocument.value,
+  output: () => props.planDocument,
   root: () => scrollEl.value,
   enabled: () => props.canExecute,
 })
 
-const feedback = ref('')
-const submitting = ref(false)
-
-/** Changes can only be requested with something to act on — an empty send would re-plan blind. */
-const canRequestChanges = computed(() => !!feedback.value.trim() || planComments.value.length > 0)
-
-/** A fresh gate (a re-plan parked again) drops the drafts rather than carrying them over. */
+/** A fresh gate (a re-plan parked again) reviews the new plan clean, from the top. */
 watch(
   () => props.approval.id,
   () => {
     resetComments()
-    feedback.value = ''
     prose.reset()
   },
 )
 
-/**
- * Accept the plan: the run advances to the committer, which persists it and arms the execution
- * loop. The window stays open — the rail disappears with the approval (live) and the tracker is
- * where the plan then executes.
- */
-async function approve() {
-  if (submitting.value || !props.canExecute) return
-  submitting.value = true
-  try {
-    await execution.approveStep(props.instanceId, props.approval.id)
-  } finally {
-    submitting.value = false
-  }
-}
+/** Whether the sidebar's run-details stack is expanded (it is, until a reviewer wants the outline). */
+const runDetailsOpen = ref(true)
 
-/** Send the plan back: the planner re-plans from the feedback + the anchored comments. */
-async function requestChanges() {
-  if (submitting.value || !canRequestChanges.value || !props.canExecute) return
-  submitting.value = true
-  try {
-    const ok = await execution.requestStepChanges(props.instanceId, props.approval.id, {
-      feedback: feedback.value.trim() || undefined,
-      comments: wireComments.value,
-    })
-    if (ok) {
-      feedback.value = ''
-      resetComments()
-    }
-  } finally {
-    submitting.value = false
-  }
+const { copy } = useCopyToClipboard()
+async function copyPlan() {
+  await copy(props.planDocument)
 }
-
-const disabledTitle = computed(() => (props.canExecute ? undefined : t('access.noRunExecute')))
 </script>
 
 <template>
-  <section
-    class="mb-4 rounded-lg border border-amber-500/40 bg-amber-500/10"
-    data-testid="initiative-plan-review"
-  >
-    <header class="flex items-start gap-2.5 px-3.5 pt-3.5">
-      <UIcon name="i-lucide-clipboard-check" class="mt-0.5 h-4 w-4 shrink-0 text-amber-300" />
-      <div class="min-w-0 flex-1">
-        <h3 class="text-[13px] font-semibold text-amber-200">
-          {{ t('initiative.planReview.title') }}
-        </h3>
-        <p class="mt-0.5 text-[12px] leading-relaxed text-amber-100/80">
-          {{ t('initiative.planReview.body') }}
-        </p>
-      </div>
-    </header>
+  <div class="flex min-h-0 flex-1 flex-col lg:flex-row" data-testid="initiative-plan-review">
+    <!-- Navigation column: the outline OUTSIDE the document rather than splitting its width — a
+         sidebar of the window, as the step reader's is. Narrower than the reader's (`w-52` against
+         its `w-72`) and held back to `lg` rather than its `md`, because this is a THREE-column
+         layout: at 768px the document would be left ~240px between the outline and the review rail,
+         which reads worse than no outline at all. Below `lg` the whole column goes; the document and
+         the commands are what a narrow screen needs.
 
-    <!-- The plan document, shown only when the gate's proposal actually IS the plan rendering
-         (`outputIsRendered`). A run planned before the engine rendered plans parks on the
-         planner's transcript summary instead, so it takes the notice below — the structured
-         sections further down are still the plan in that case. -->
-    <div v-if="hasOutput" class="mt-3 flex min-h-0 gap-3 px-3.5">
-      <!-- Outline: the navigation the rail had none of. Inline rather than a full sidebar — the
-           tracker window already spends its end-side column on run metadata. -->
+         Its presence tracks its two contents INDEPENDENTLY rather than the outline alone. Gating the
+         run details on `outline.hasToc` would make whether this window still reports its model / run
+         id / token spend depend on whether the plan renderer happened to emit a heading — a fact
+         owned by `renderInitiativePlanForReview`, in another package, with nothing pinning it. The
+         step reader keeps the same document-level affordances out of its own `hasToc` guard for that
+         reason, in a main-column header this surface does not have. -->
+    <aside
+      v-if="outline.hasToc || $slots['run-details']"
+      class="hidden w-52 shrink-0 flex-col border-e border-slate-800 bg-slate-900/60 lg:flex"
+    >
+      <div class="flex items-center gap-0.5 border-b border-slate-800 px-3 py-2">
+        <span
+          v-if="outline.hasToc"
+          class="min-w-0 flex-1 truncate text-[11px] font-semibold uppercase tracking-wide text-slate-500"
+        >
+          {{ t('panels.stepDetail.contents') }}
+        </span>
+        <span v-else class="flex-1" />
+        <!-- Collapse-all tracks the outline: with no headings the only section is the untitled
+             preamble, which renders no toggle of its own, so collapsing it would hide the whole
+             plan with nothing on screen to bring it back. Copying it does not — that is about the
+             document, which exists either way. -->
+        <UButton
+          v-if="outline.hasToc"
+          :icon="allCollapsed ? 'i-lucide-unfold-vertical' : 'i-lucide-fold-vertical'"
+          color="neutral"
+          variant="ghost"
+          size="xs"
+          :title="
+            allCollapsed ? t('panels.stepDetail.expandAll') : t('panels.stepDetail.collapseAll')
+          "
+          @click="setAll(!allCollapsed)"
+        />
+        <UButton
+          icon="i-lucide-copy"
+          color="neutral"
+          variant="ghost"
+          size="xs"
+          :title="t('panels.stepDetail.copyRawOutput')"
+          @click="copyPlan"
+        />
+      </div>
       <nav
         v-if="outline.hasToc"
         data-testid="initiative-plan-toc"
-        class="hidden max-h-80 w-48 shrink-0 space-y-0.5 overflow-y-auto border-e border-amber-500/20 pe-2 md:block"
+        :aria-label="t('panels.stepDetail.contents')"
+        class="flex-1 space-y-0.5 overflow-y-auto px-2 py-2"
       >
         <button
           v-for="s in tocSections"
           :key="s.id"
-          class="block w-full truncate rounded px-1.5 py-1 text-start text-[12px] transition"
+          class="block w-full truncate rounded-md px-2 py-1 text-start text-[12px] transition"
           :class="
             activeId === s.id
-              ? 'bg-amber-500/20 font-medium text-amber-100'
-              : 'text-amber-200/60 hover:bg-amber-500/10 hover:text-amber-100'
+              ? 'bg-amber-500/15 font-medium text-amber-100'
+              : 'text-slate-400 hover:bg-slate-800/60 hover:text-slate-200'
           "
-          :style="{ paddingLeft: `${(s.depth - outline.minDepth) * 0.7 + 0.4}rem` }"
+          :style="{ paddingLeft: `${(s.depth - outline.minDepth) * 0.7 + 0.5}rem` }"
           :title="s.title"
           @click="goTo(s.id)"
         >
           {{ s.title }}
         </button>
       </nav>
-
+      <!-- Run details (the model, the run id, the token telemetry). Filled by the host, which
+           already resolves the bundle through `useResultViewRunMeta`; it keeps its home in a
+           sidebar here rather than disappearing for the duration of the review. Open, but
+           collapsible: it is a stack of seven labelled fields, and a reviewer navigating a long
+           plan should be able to give the outline the whole column. With no outline above it there
+           is no column to give back, so it takes the space instead of leaving 55% of it empty. -->
       <div
-        ref="scrollEl"
-        data-testid="initiative-plan-document"
-        class="max-h-80 min-w-0 flex-1 overflow-y-auto rounded border border-amber-500/20 bg-slate-950/40 p-3"
-        @scroll="onScroll"
+        v-if="$slots['run-details']"
+        class="flex flex-col"
+        :class="
+          outline.hasToc ? 'max-h-[45%] shrink-0 border-t border-slate-800' : 'min-h-0 flex-1'
+        "
       >
-        <section
-          v-for="s in outline.sections"
-          :id="s.id"
-          :key="s.id"
-          :ref="(el) => (sectionEls[s.id] = el as HTMLElement | null)"
-          class="scroll-mt-2"
+        <button
+          type="button"
+          data-testid="initiative-plan-run-meta-toggle"
+          class="flex shrink-0 items-center gap-1.5 px-3 py-2 text-start transition hover:bg-slate-800/40"
+          :aria-expanded="runDetailsOpen"
+          @click="runDetailsOpen = !runDetailsOpen"
         >
-          <button
-            v-if="s.depth > 0"
-            class="group flex w-full items-center gap-1.5 rounded py-0.5 text-start transition hover:text-white"
-            @click="toggle(s.id)"
-          >
-            <UIcon
-              name="i-lucide-chevron-right"
-              class="h-3.5 w-3.5 shrink-0 text-slate-500 transition-transform"
-              :class="collapsed[s.id] ? '' : 'rotate-90'"
-            />
-            <span
-              class="font-semibold text-slate-100"
-              :class="s.depth <= 1 ? 'text-sm' : 'text-[13px]'"
-              v-html="s.titleHtml"
-            />
-          </button>
-          <!-- `review-mode` carries the click-to-comment affordance, so it tracks the same RBAC
-               gate the composer does — a viewer gets the document, not hover targets that lead
-               nowhere. -->
-          <!-- eslint-disable-next-line vue/no-v-html -->
-          <div
-            v-show="!collapsed[s.id]"
-            class="reader-prose mt-0.5 text-[12px] leading-relaxed text-slate-300"
-            :class="[s.depth > 0 ? 'ps-5' : '', canExecute ? 'review-mode' : '']"
-            @click="onProseClick"
-            v-html="s.bodyHtml"
+          <span class="flex-1 text-[11px] font-semibold uppercase tracking-wide text-slate-500">
+            {{ t('panels.stepDetail.details') }}
+          </span>
+          <UIcon
+            :name="runDetailsOpen ? 'i-lucide-chevron-down' : 'i-lucide-chevron-up'"
+            class="h-3.5 w-3.5 shrink-0 text-slate-500"
           />
-        </section>
+        </button>
+        <div
+          v-if="runDetailsOpen"
+          data-testid="initiative-plan-run-meta"
+          class="min-h-0 flex-1 overflow-y-auto px-3 pb-3"
+        >
+          <slot name="run-details" />
+        </div>
       </div>
-    </div>
-    <p v-else class="mt-2 px-3.5 text-[12px] text-amber-100/70">
-      {{ t('initiative.planReview.noDocument') }}
-    </p>
+    </aside>
 
-    <!-- Comment composer for the block just clicked, then the anchored comments so far. -->
-    <div v-if="draftTarget" class="mt-3 px-3.5" data-testid="initiative-plan-composer">
-      <div class="rounded-lg border border-indigo-500/40 bg-indigo-500/5 p-2.5">
-        <div class="mb-1 text-[10px] uppercase tracking-wide text-indigo-300">
-          {{ t('panels.stepDetail.commentingOn') }}
-        </div>
-        <pre
-          class="mb-2 max-h-20 overflow-auto whitespace-pre-wrap rounded bg-slate-950/60 p-1.5 text-[11px] text-slate-300"
-          >{{ draftTarget.quotedSource }}</pre>
-        <UTextarea
-          v-model="draftBody"
-          data-testid="initiative-plan-comment-body"
-          :rows="2"
-          autoresize
-          size="sm"
-          class="w-full"
-          :placeholder="t('panels.stepDetail.commentPlaceholder')"
+    <!-- The plan itself, with the full height of the window to be read in. -->
+    <div
+      ref="scrollEl"
+      data-testid="initiative-plan-document"
+      class="min-h-0 min-w-0 flex-1 overflow-y-auto px-5 py-4"
+      @scroll="onScroll"
+    >
+      <!-- No `max-w-*` reading measure here: with the outline and the review rail both taking a
+           fixed column out of the shell's `5xl`, this one is ~490px wide at every size that renders
+           it, so a cap would only ever be dead markup. -->
+      <section
+        v-for="s in outline.sections"
+        :id="s.id"
+        :key="s.id"
+        :ref="(el) => (sectionEls[s.id] = el as HTMLElement | null)"
+        class="scroll-mt-2"
+      >
+        <button
+          v-if="s.depth > 0"
+          class="group flex w-full items-center gap-1.5 rounded py-0.5 text-start transition hover:text-white"
+          :aria-expanded="!collapsed[s.id]"
+          @click="toggle(s.id)"
+        >
+          <UIcon
+            name="i-lucide-chevron-right"
+            class="h-3.5 w-3.5 shrink-0 text-slate-500 transition-transform group-hover:text-slate-300"
+            :class="collapsed[s.id] ? '' : 'rotate-90'"
+          />
+          <span
+            class="font-semibold text-slate-100"
+            :class="s.depth <= 1 ? 'text-base' : s.depth === 2 ? 'text-sm' : 'text-[13px]'"
+            v-html="s.titleHtml"
+          />
+        </button>
+        <!-- `review-mode` carries the click-to-comment affordance, so it tracks the same RBAC
+             gate the composer does — a viewer gets the document, not hover targets that lead
+             nowhere. -->
+        <!-- eslint-disable-next-line vue/no-v-html -->
+        <div
+          v-show="!collapsed[s.id]"
+          class="reader-prose mt-0.5 text-[13px] leading-relaxed text-slate-300"
+          :class="[s.depth > 0 ? 'ps-5' : '', canExecute ? 'review-mode' : '']"
+          @click="onProseClick"
+          v-html="s.bodyHtml"
         />
-        <div class="mt-2 flex justify-end gap-2">
-          <UButton color="neutral" variant="ghost" size="xs" @click="cancelDraft">
-            {{ t('common.cancel') }}
-          </UButton>
-          <UButton
-            color="primary"
-            size="xs"
-            data-testid="initiative-plan-comment-add"
-            :disabled="!draftBody.trim()"
-            @click="addDraftComment"
-          >
-            {{ t('panels.stepDetail.addComment') }}
-          </UButton>
-        </div>
-      </div>
+      </section>
     </div>
 
-    <ul v-if="planComments.length" class="mt-3 space-y-2 px-3.5">
-      <li
-        v-for="(c, idx) in planComments"
-        :key="idx"
-        data-testid="initiative-plan-comment"
-        class="rounded-lg border border-slate-700 bg-slate-900/50 p-2.5"
-      >
-        <div class="mb-1 flex items-start justify-between gap-2">
-          <div class="text-[10px] uppercase tracking-wide text-slate-500">
-            {{ t('panels.stepDetail.commentN', { number: idx + 1 }) }}
+    <!-- Review rail: what the human is being asked, the anchored comments so far, and the two
+         commands — the step reader's end-side rail. Below `lg` it drops under the document, capped
+         so a long comment list can't crowd the plan off the screen. -->
+    <aside
+      :aria-label="t('initiative.planReview.title')"
+      class="flex max-h-[55%] w-full shrink-0 flex-col border-t border-slate-800 bg-slate-900/60 lg:max-h-none lg:w-72 lg:border-s lg:border-t-0"
+    >
+      <div class="border-b border-slate-800 px-4 py-3">
+        <!-- A HEADING, not a styled div: this rail is what the window is now for, so the surface
+             that asks the human for a decision has to be reachable as one. -->
+        <h3
+          class="flex items-center gap-1.5 text-[11px] font-semibold uppercase tracking-wide text-amber-400"
+        >
+          <UIcon name="i-lucide-clipboard-check" class="h-3.5 w-3.5 shrink-0" />
+          {{ t('initiative.planReview.title') }}
+        </h3>
+        <p class="mt-1 text-[12px] leading-relaxed text-slate-400">
+          {{ t('initiative.planReview.body') }}
+        </p>
+      </div>
+
+      <div class="flex-1 space-y-3 overflow-y-auto overscroll-contain px-4 py-3">
+        <!-- Composer for the block just clicked. -->
+        <div
+          v-if="draftTarget"
+          data-testid="initiative-plan-composer"
+          class="rounded-lg border border-indigo-500/40 bg-indigo-500/5 p-2.5"
+        >
+          <div class="mb-1 text-[10px] uppercase tracking-wide text-indigo-300">
+            {{ t('panels.stepDetail.commentingOn') }}
+          </div>
+          <pre
+            class="mb-2 max-h-20 overflow-auto whitespace-pre-wrap rounded bg-slate-950/60 p-1.5 text-[11px] text-slate-300"
+            >{{ draftTarget.quotedSource }}</pre>
+          <UTextarea
+            v-model="draftBody"
+            data-testid="initiative-plan-comment-body"
+            :rows="2"
+            autoresize
+            size="sm"
+            class="w-full"
+            :placeholder="t('panels.stepDetail.commentPlaceholder')"
+          />
+          <div class="mt-2 flex justify-end gap-2">
+            <UButton color="neutral" variant="ghost" size="xs" @click="cancelDraft">
+              {{ t('common.cancel') }}
+            </UButton>
+            <UButton
+              color="primary"
+              size="xs"
+              data-testid="initiative-plan-comment-add"
+              :disabled="!draftBody.trim()"
+              @click="addDraftComment"
+            >
+              {{ t('panels.stepDetail.addComment') }}
+            </UButton>
           </div>
-          <button
-            class="text-slate-500 transition hover:text-rose-400"
-            :title="t('panels.stepDetail.removeComment')"
-            @click="removeComment(idx)"
-          >
-            <UIcon name="i-lucide-x" class="h-3.5 w-3.5" />
-          </button>
         </div>
-        <pre
-          class="mb-1 max-h-16 overflow-auto whitespace-pre-wrap rounded bg-slate-950/50 p-1.5 text-[10px] text-slate-400"
-          >{{ c.quotedSource }}</pre>
-        <p class="text-[12px] text-slate-200">{{ c.body }}</p>
-      </li>
-    </ul>
 
-    <!-- Overall feedback + the two actions. Feedback stays visible rather than hiding behind a
-         "request changes" step: with per-block comments in play the human is already composing a
-         review, and a hidden field reads as "there is nothing more to say". -->
-    <div class="mt-3 px-3.5 pb-3.5">
-      <UTextarea
-        v-model="feedback"
-        data-testid="initiative-plan-feedback"
-        :rows="2"
-        autoresize
-        size="sm"
-        class="w-full"
-        :placeholder="t('initiative.planReview.feedbackPlaceholder')"
-      />
-      <div class="mt-2 flex flex-wrap items-center gap-2">
-        <UButton
-          color="primary"
-          size="xs"
-          icon="i-lucide-check"
-          data-testid="initiative-plan-approve"
-          :loading="submitting"
-          :disabled="!canExecute"
-          :title="disabledTitle"
-          @click="approve"
+        <!-- The anchored comments so far. -->
+        <div
+          v-for="(c, idx) in planComments"
+          :key="idx"
+          data-testid="initiative-plan-comment"
+          class="rounded-lg border border-slate-800 bg-slate-900/50 p-2.5"
         >
-          {{ t('initiative.planReview.approve') }}
-        </UButton>
-        <UButton
-          color="warning"
-          variant="soft"
-          size="xs"
-          icon="i-lucide-rotate-ccw"
-          data-testid="initiative-plan-send-back"
-          :loading="submitting"
-          :disabled="!canRequestChanges || !canExecute"
-          :title="
-            canExecute && !canRequestChanges
-              ? t('initiative.planReview.needsFeedback')
-              : disabledTitle
-          "
-          @click="requestChanges"
+          <div class="mb-1 flex items-start justify-between gap-2">
+            <div class="text-[10px] uppercase tracking-wide text-slate-500">
+              {{ t('panels.stepDetail.commentN', { number: idx + 1 }) }}
+            </div>
+            <button
+              class="text-slate-500 transition hover:text-rose-400"
+              :title="t('panels.stepDetail.removeComment')"
+              @click="removeComment(idx)"
+            >
+              <UIcon name="i-lucide-x" class="h-3.5 w-3.5" />
+            </button>
+          </div>
+          <pre
+            class="mb-1 max-h-16 overflow-auto whitespace-pre-wrap rounded bg-slate-950/50 p-1.5 text-[10px] text-slate-400"
+            >{{ c.quotedSource }}</pre>
+          <p class="text-[12px] text-slate-200">{{ c.body }}</p>
+        </div>
+
+        <!-- Only worth saying where clicking a block does something (the RBAC to act on it) and
+             where nothing has been said yet. -->
+        <p
+          v-if="canExecute && !draftTarget && !planComments.length"
+          class="text-[11px] leading-relaxed text-slate-400"
         >
-          {{ t('initiative.planReview.sendBack') }}
-        </UButton>
-        <!-- Only worth saying where clicking a block does something (a document + the RBAC to
-             act on it). -->
-        <p v-if="hasOutput && canExecute" class="text-[10px] text-amber-100/60">
           {{ t('initiative.planReview.commentHint') }}
         </p>
       </div>
-    </div>
-  </section>
+
+      <!-- Overall feedback + the two commands. Feedback stays visible rather than hiding behind a
+           "request changes" step: with per-block comments in play the human is already composing a
+           review, and a hidden field reads as "there is nothing more to say". -->
+      <InitiativePlanDecision
+        class="border-t border-slate-800 px-4 pt-3 pb-[calc(0.75rem+env(safe-area-inset-bottom))]"
+        :approval-id="approval.id"
+        :instance-id="instanceId"
+        :can-execute="canExecute"
+        :comments="wireComments"
+        @sent="resetComments"
+      />
+    </aside>
+  </div>
 </template>

package/app/components/initiative/InitiativeTrackerWindow.vue

@@ -23,10 +23,12 @@ import {
   INITIATIVE_STATUS_LABEL_KEYS,
   initiativeProgress,
   pendingCheckpointPhase,
+  planReviewDocument,
 } from '~/utils/initiative'
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
 import StepRunMeta from '~/components/panels/StepRunMeta.vue'
 import InitiativePlanReview from '~/components/initiative/InitiativePlanReview.vue'
+import InitiativePlanNotice from '~/components/initiative/InitiativePlanNotice.vue'
 
 const board = useBoardStore()
 const initiatives = useInitiativesStore()
@@ -61,6 +63,24 @@ const {
   stepIndex: () => stepIndex.value,
 })
 
+/**
+ * The `StepRunMeta` prop bundle, or null when no step speaks for this window. Bound as one object
+ * because it has two homes — the tracker's end-side column, and the plan review's sidebar while the
+ * review owns the window — and the run details must read identically in both.
+ */
+const runMeta = computed(() =>
+  metaStep.value
+    ? {
+        step: metaStep.value,
+        instanceId: runId.value,
+        stepNumber: position.value,
+        totalSteps: totalSteps.value,
+        runFailed: runFailed.value,
+        failureAt: failureAt.value,
+      }
+    : null,
+)
+
 const phases = computed(() => initiative.value?.phases ?? [])
 function itemsOf(phaseId: string): InitiativeItem[] {
   return (initiative.value?.items ?? []).filter((i) => i.phaseId === phaseId)
@@ -103,9 +123,19 @@ async function checkpointControl(action: 'resume' | 'cancel') {
 // ---- Plan review: the planner step's human gate, resolved right here -----------------------
 // Derived from the BLOCK (via the shared planning composable), not from this window's own
 // `stepIndex`: the card / inspector open the tracker with no step, and that is the entry point a
-// human parked on the gate actually uses. So the rail appears on every route into the window.
+// human parked on the gate actually uses. So the review appears on every route into the window.
 const { planApproval } = useInitiativePlanning(() => blockId.value ?? '')
 
+/**
+ * The plan document the parked gate offers, or `''` — which is also the layout decision. A rendered
+ * plan is a REPLACEMENT for the tracker body rather than a card above it: the render reads the
+ * ingested entity, so the sections below would be a second copy of what the reviewer is reading,
+ * and everything the tracker adds on top (PR links, item curation, checkpoints, follow-ups) is
+ * execution-time state that cannot exist until the plan is committed. With no document, the tracker
+ * body IS the plan, so the gate takes the compact notice above it instead.
+ */
+const planDocument = computed(() => planReviewDocument(planApproval.value))
+
 const policyRules = computed(() => initiative.value?.policy?.rules ?? [])
 function ruleAxes(rule: { minComplexity?: number; minRisk?: number; minImpact?: number }): string {
   const axes = [
@@ -236,30 +266,54 @@ async function savePolicy() {
       </UBadge>
     </template>
 
-    <div class="flex min-h-0 flex-1">
+    <!-- The planner's human gate, with the plan rendered as a document. This window is where the
+         park ROUTES (the planner's archetype declares this result view), so it is the only surface
+         that can resolve it — and while it is parked the review OWNS the window: an outline sidebar,
+         the plan at full height, per-block commenting and the commands in an end-side rail, the same
+         tools and the same shape the step reader gives the architect's prose. The tracker body it
+         replaces would only repeat the plan (see `planDocument`). -->
+    <InitiativePlanReview
+      v-if="planApproval && planDocument"
+      :approval="planApproval.approval"
+      :instance-id="planApproval.instanceId"
+      :can-execute="access.canExecuteRuns.value"
+      :plan-document="planDocument"
+    >
+      <template v-if="runMeta" #run-details>
+        <StepRunMeta v-bind="runMeta" />
+      </template>
+    </InitiativePlanReview>
+
+    <div v-else class="flex min-h-0 flex-1">
       <div class="min-w-0 flex-1 overflow-y-auto px-5 py-4">
-        <!-- No entity yet (module unwired / still creating) -->
+        <!-- A parked gate whose step rendered no plan: the commands, plus a notice pointing at the
+             sections below — which in that case are the only rendering of the plan there is.
+             Deliberately OUTSIDE the entity branch: the gate lives on the RUN, so it is parked
+             before `initiatives.load()` has resolved (and stays parked if it fails), and a window
+             that answered such a gate with the empty state alone would leave it unresolvable from
+             the UI. `hasSections` is what keeps the notice honest about whether the sections it
+             points at are actually rendered underneath. -->
+        <InitiativePlanNotice
+          v-if="planApproval"
+          :approval="planApproval.approval"
+          :instance-id="planApproval.instanceId"
+          :can-execute="access.canExecuteRuns.value"
+          :has-sections="!!initiative"
+        />
+
+        <!-- No entity yet (module unwired / still creating). Centred in the column when it is the
+             only thing in it; merely inset when the notice above it means `h-full` would overflow
+             the scroller by the notice's own height. -->
         <div
           v-if="!initiative"
-          class="flex h-full flex-col items-center justify-center gap-2 text-center text-slate-400"
+          class="flex flex-col items-center justify-center gap-2 text-center text-slate-400"
+          :class="planApproval ? 'py-16' : 'h-full'"
         >
           <UIcon name="i-lucide-milestone" class="h-8 w-8 opacity-40" />
           <p class="text-sm">{{ t('initiative.tracker.empty') }}</p>
         </div>
 
         <template v-else>
-          <!-- The planner's human gate. This window is where the park ROUTES (the planner's
-               archetype declares this result view), so it is the only surface that can resolve
-               it — and the plan it judges is rendered as a navigable document with per-block
-               commenting, the same tools the step reader gives the architect's prose. -->
-          <InitiativePlanReview
-            v-if="planApproval"
-            :approval="planApproval.approval"
-            :instance-id="planApproval.instanceId"
-            :can-execute="access.canExecuteRuns.value"
-            :output-is-rendered="planApproval.outputIsRendered"
-          />
-
           <!-- Paused at a phase checkpoint (D2): a completed checkpoint phase is awaiting
                    review before the next phase spawns. Read the phase's artifacts/PRs below,
                    then resume (continue) or cancel (stop) the initiative right here. -->
@@ -646,18 +700,11 @@ async function savePolicy() {
            through `useResultViewRunMeta`, so it is present on the card / inspector entry point
            too — where this window carries no step index of its own. -->
       <aside
-        v-if="metaStep"
+        v-if="runMeta"
         data-testid="initiative-tracker-run-meta"
         class="hidden w-60 shrink-0 flex-col gap-4 overflow-y-auto border-s border-slate-800 bg-slate-900/50 px-4 py-4 lg:flex"
       >
-        <StepRunMeta
-          :step="metaStep"
-          :instance-id="runId"
-          :step-number="position"
-          :total-steps="totalSteps"
-          :run-failed="runFailed"
-          :failure-at="failureAt"
-        />
+        <StepRunMeta v-bind="runMeta" />
       </aside>
     </div>
   </ResultWindowShell>

package/app/utils/initiative.spec.ts

@@ -9,6 +9,7 @@ import {
   isPendingQuestion,
   orderInterviewQuestions,
   pendingCheckpointPhase,
+  planReviewDocument,
   selectPlanApproval,
 } from './initiative'
 
@@ -205,6 +206,48 @@ describe('selectPlanApproval', () => {
   })
 })
 
+// Which shape the plan gate takes in the tracker window: a document review that OWNS the window, or
+// the compact notice above the tracker's own sections. Both the window's layout and the review
+// surface read this one value, so these pin the cases where "there is a plan to read" is not the
+// same as "the proposal is non-empty".
+
+describe('planReviewDocument', () => {
+  const gate = (proposal: string | null | undefined, outputIsRendered: boolean) => ({
+    approval: { proposal },
+    outputIsRendered,
+  })
+
+  it('is the proposal when the step says it IS the plan rendering', () => {
+    expect(planReviewDocument(gate('# Initiative plan\n\n## Goal', true))).toBe(
+      '# Initiative plan\n\n## Goal',
+    )
+  })
+
+  it('returns the proposal verbatim, so comment anchors stay on the lines they quote', () => {
+    // Anchoring is by SOURCE LINE, so trimming a leading newline would shift every anchor up one.
+    expect(planReviewDocument(gate('\n# Initiative plan\n', true))).toBe('\n# Initiative plan\n')
+  })
+
+  it('reads an un-rendered proposal as no document, however substantial it looks', () => {
+    // The planner's transcript summary: a perfectly non-empty string that is not the plan. Showing
+    // it under a table of contents is the failure the rendered review exists to end.
+    expect(
+      planReviewDocument(gate('I drafted a three-phase plan and stopped for review.', false)),
+    ).toBe('')
+  })
+
+  it('reads a rendered but blank proposal as no document', () => {
+    expect(planReviewDocument(gate('   \n  ', true))).toBe('')
+    expect(planReviewDocument(gate(null, true))).toBe('')
+    expect(planReviewDocument(gate(undefined, true))).toBe('')
+  })
+
+  it('has no document when nothing is parked', () => {
+    expect(planReviewDocument(null)).toBe('')
+    expect(planReviewDocument(undefined)).toBe('')
+  })
+})
+
 /**
  * These tables are the reason the initiative card and the inspector word one park identically,
  * and they are exactly the shape both i18n drift guards are blind to: the typed-key check and

package/app/utils/initiative.ts

@@ -103,6 +103,29 @@ export function selectPlanApproval<A extends { agentKind: string }>(
   return approvals.find((a) => resultViewOf(a.agentKind) !== INTERVIEW_GATE_RESULT_VIEW)
 }
 
+/**
+ * The plan DOCUMENT a parked gate offers for review — its proposal, but only once the step says
+ * that proposal IS the plan rendering (`outputIsRendered`); `''` otherwise.
+ *
+ * A step that rendered nothing parks on the planner's transcript SUMMARY, which is a perfectly
+ * non-empty string, so an emptiness check alone would present one sentence under a table of
+ * contents as though it were the plan. `''` is what routes such a gate to the compact notice
+ * instead — and the SAME value decides the tracker window's layout (a document review takes the
+ * whole window; a notice sits above the tracker's own sections), so the surface and its host can
+ * never disagree about which shape is on screen.
+ *
+ * Rendered-but-blank counts as no document. The proposal comes back VERBATIM, never trimmed: the
+ * review anchors comments to source LINE numbers, so dropping a leading newline would shift every
+ * anchor off the block it quotes.
+ */
+export function planReviewDocument(
+  gate: { approval: { proposal?: string | null }; outputIsRendered: boolean } | null | undefined,
+): string {
+  if (!gate?.outputIsRendered) return ''
+  const proposal = gate.approval.proposal ?? ''
+  return proposal.trim() ? proposal : ''
+}
+
 /** Follow-up triage status → i18n label key. Exhaustive so a new status fails the build. */
 export const INITIATIVE_FOLLOWUP_STATUS_LABEL_KEYS: Record<InitiativeFollowUp['status'], string> = {
   open: 'initiative.followUpStatus.open',

package/i18n/locales/de.json

@@ -4426,11 +4426,12 @@
     },
     "planReview": {
       "title": "Dieser Plan wartet auf dich",
-      "body": "Der Planner hat die Phasen und Aufgaben unten entworfen. Gib sie frei, um den Plan zu committen und die Arbeit zu starten, oder schicke den Plan mit deinen Änderungswünschen zurück.",
+      "body": "Der Planner hat diese Phasen und Aufgaben entworfen. Gib sie frei, um den Plan zu committen und die Arbeit zu starten, oder schicke den Plan mit deinen Änderungswünschen zurück.",
       "approve": "Plan freigeben",
       "feedbackPlaceholder": "Was soll der Planner ändern? Umfang, Reihenfolge der Phasen, fehlende Arbeit, eine Aufgabe, die woanders hingehört …",
       "sendBack": "An den Planner zurückschicken",
-      "noDocument": "Dieser Plan entstand, bevor die Plattform Pläne zur Prüfung gerendert hat — es gibt kein Dokument zum Navigieren; die Abschnitte unten sind der Plan.",
+      "noDocument": "Dieser Planungsschritt hat kein Plandokument zur Prüfung hinterlassen, es gibt hier also nichts zu navigieren.",
+      "noDocumentSections": "Der Plan sind die Abschnitte unten.",
       "needsFeedback": "Füge zuerst einen Kommentar oder eine Rückmeldung hinzu — der Planer plant damit neu.",
       "commentHint": "Klicke auf einen Teil des Plans, um ihn zu kommentieren."
     },

package/i18n/locales/en.json

@@ -5645,11 +5645,12 @@
     },
     "planReview": {
       "title": "This plan is waiting for you",
-      "body": "The planner drafted the phases and items below. Approve them to commit the plan and start the work, or send the plan back with what to change.",
+      "body": "The planner drafted these phases and items. Approve them to commit the plan and start the work, or send the plan back with what to change.",
       "approve": "Approve plan",
       "feedbackPlaceholder": "What should the planner change? Scope, phase order, missing work, an item that belongs elsewhere…",
       "sendBack": "Send back to the planner",
-      "noDocument": "This plan was drafted before the platform rendered plans for review, so there is no document to navigate — the sections below are the plan.",
+      "noDocument": "This planning step left no plan document to review, so there is nothing to navigate here.",
+      "noDocumentSections": "The sections below are the plan.",
       "needsFeedback": "Add a comment or some feedback first — the planner re-plans from it.",
       "commentHint": "Click any part of the plan to comment on it."
     },

package/i18n/locales/es.json

@@ -5453,11 +5453,12 @@
     },
     "planReview": {
       "title": "Este plan te está esperando",
-      "body": "El planificador redactó las fases y los elementos de abajo. Apruébalos para confirmar el plan y empezar el trabajo, o devuelve el plan indicando qué cambiar.",
+      "body": "El planificador redactó estas fases y estos elementos. Apruébalos para confirmar el plan y empezar el trabajo, o devuelve el plan indicando qué cambiar.",
       "approve": "Aprobar plan",
       "feedbackPlaceholder": "¿Qué debería cambiar el planificador? Alcance, orden de las fases, trabajo que falta, un elemento que va en otro sitio…",
       "sendBack": "Devolver al planificador",
-      "noDocument": "Este plan se redactó antes de que la plataforma generara planes para revisión, así que no hay documento que recorrer: las secciones de abajo son el plan.",
+      "noDocument": "Este paso de planificación no dejó ningún documento del plan para revisar, así que aquí no hay nada que recorrer.",
+      "noDocumentSections": "Las secciones de abajo son el plan.",
       "needsFeedback": "Añade primero un comentario o algún comentario general: el planificador replanifica a partir de ello.",
       "commentHint": "Haz clic en cualquier parte del plan para comentarla."
     },

package/i18n/locales/fr.json

@@ -5453,11 +5453,12 @@
     },
     "planReview": {
       "title": "Ce plan vous attend",
-      "body": "Le planificateur a rédigé les phases et les éléments ci-dessous. Approuvez-les pour valider le plan et lancer le travail, ou renvoyez le plan en indiquant ce qu'il faut changer.",
+      "body": "Le planificateur a rédigé ces phases et ces éléments. Approuvez-les pour valider le plan et lancer le travail, ou renvoyez le plan en indiquant ce qu'il faut changer.",
       "approve": "Approuver le plan",
       "feedbackPlaceholder": "Que doit changer le planificateur ? Périmètre, ordre des phases, travail manquant, un élément qui a sa place ailleurs…",
       "sendBack": "Renvoyer au planificateur",
-      "noDocument": "Ce plan a été rédigé avant que la plateforme ne produise des plans à relire ; il n'y a donc pas de document à parcourir — les sections ci-dessous sont le plan.",
+      "noDocument": "Cette étape de planification n'a laissé aucun document de plan à relire, il n'y a donc rien à parcourir ici.",
+      "noDocumentSections": "Les sections ci-dessous sont le plan.",
       "needsFeedback": "Ajoutez d'abord un commentaire ou un retour : le planificateur s'en sert pour replanifier.",
       "commentHint": "Cliquez sur une partie du plan pour la commenter."
     },

package/i18n/locales/he.json

@@ -5464,11 +5464,12 @@
     },
     "planReview": {
       "title": "התוכנית הזו ממתינה לך",
-      "body": "המתכנן ניסח את השלבים והפריטים שלמטה. אשרו אותם כדי לשמור את התוכנית ולהתחיל בעבודה, או החזירו את התוכנית עם מה שצריך לשנות.",
+      "body": "המתכנן ניסח את השלבים והפריטים האלה. אשרו אותם כדי לשמור את התוכנית ולהתחיל בעבודה, או החזירו את התוכנית עם מה שצריך לשנות.",
       "approve": "אישור התוכנית",
       "feedbackPlaceholder": "מה המתכנן צריך לשנות? היקף, סדר השלבים, עבודה חסרה, פריט ששייך למקום אחר…",
       "sendBack": "החזרה למתכנן",
-      "noDocument": "התוכנית הזו נוסחה לפני שהפלטפורמה יצרה תוכניות לבדיקה, ולכן אין מסמך לנווט בו — הסעיפים שלמטה הם התוכנית.",
+      "noDocument": "שלב התכנון הזה לא השאיר מסמך תוכנית לבדיקה, ולכן אין כאן במה לנווט.",
+      "noDocumentSections": "הסעיפים שלמטה הם התוכנית.",
       "needsFeedback": "הוסיפו תחילה הערה או משוב — המתכנן מתכנן מחדש על סמך זה.",
       "commentHint": "לחצו על כל חלק בתוכנית כדי להעיר עליו."
     },

package/i18n/locales/it.json

@@ -4426,11 +4426,12 @@
     },
     "planReview": {
       "title": "Questo piano ti sta aspettando",
-      "body": "Il planner ha redatto le fasi e gli elementi qui sotto. Approvali per confermare il piano e avviare il lavoro, oppure rimanda indietro il piano indicando cosa cambiare.",
+      "body": "Il planner ha redatto queste fasi e questi elementi. Approvali per confermare il piano e avviare il lavoro, oppure rimanda indietro il piano indicando cosa cambiare.",
       "approve": "Approva il piano",
       "feedbackPlaceholder": "Cosa deve cambiare il planner? Ambito, ordine delle fasi, lavoro mancante, un elemento che sta altrove…",
       "sendBack": "Rimanda al planner",
-      "noDocument": "Questo piano è stato redatto prima che la piattaforma generasse piani da revisionare, quindi non c'è un documento da percorrere: le sezioni qui sotto sono il piano.",
+      "noDocument": "Questo passaggio di pianificazione non ha lasciato alcun documento del piano da revisionare, quindi qui non c'è nulla da percorrere.",
+      "noDocumentSections": "Le sezioni qui sotto sono il piano.",
       "needsFeedback": "Aggiungi prima un commento o un riscontro: il pianificatore ripianifica a partire da questo.",
       "commentHint": "Fai clic su una parte del piano per commentarla."
     },

package/i18n/locales/ja.json

@@ -5465,11 +5465,12 @@
     },
     "planReview": {
       "title": "この計画が承認を待っています",
-      "body": "プランナーが以下のフェーズと項目を起草しました。承認すると計画がコミットされ、作業が始まります。変更したい点がある場合は、その内容を添えて計画を差し戻してください。",
+      "body": "プランナーがこれらのフェーズと項目を起草しました。承認すると計画がコミットされ、作業が始まります。変更したい点がある場合は、その内容を添えて計画を差し戻してください。",
       "approve": "計画を承認",
       "feedbackPlaceholder": "プランナーに変更してほしい点は何ですか。範囲、フェーズの順序、不足している作業、別の場所に属する項目など…",
       "sendBack": "プランナーに差し戻す",
-      "noDocument": "この計画は、プラットフォームがレビュー用の計画を生成する前に作成されたため、たどれる文書がありません。下のセクションが計画そのものです。",
+      "noDocument": "この計画ステップはレビュー用の計画ドキュメントを残さなかったため、ここにはたどれるものがありません。",
+      "noDocumentSections": "下のセクションが計画そのものです。",
       "needsFeedback": "まずコメントかフィードバックを入力してください。プランナーはそれをもとに計画し直します。",
       "commentHint": "計画の任意の箇所をクリックするとコメントできます。"
     },

package/i18n/locales/pl.json

@@ -5453,11 +5453,12 @@
     },
     "planReview": {
       "title": "Ten plan czeka na Ciebie",
-      "body": "Planer przygotował poniższe fazy i elementy. Zatwierdź je, aby zapisać plan i rozpocząć pracę, albo odeślij plan z informacją, co zmienić.",
+      "body": "Planer przygotował te fazy i elementy. Zatwierdź je, aby zapisać plan i rozpocząć pracę, albo odeślij plan z informacją, co zmienić.",
       "approve": "Zatwierdź plan",
       "feedbackPlaceholder": "Co planer ma zmienić? Zakres, kolejność faz, brakująca praca, element, który pasuje gdzie indziej…",
       "sendBack": "Odeślij do planera",
-      "noDocument": "Ten plan powstał, zanim platforma zaczęła generować plany do przeglądu, więc nie ma dokumentu do przeglądania — plan stanowią sekcje poniżej.",
+      "noDocument": "Ten krok planowania nie pozostawił dokumentu planu do przeglądu, więc nie ma tu po czym nawigować.",
+      "noDocumentSections": "Plan stanowią sekcje poniżej.",
       "needsFeedback": "Dodaj najpierw komentarz lub uwagi — planista na ich podstawie planuje ponownie.",
       "commentHint": "Kliknij dowolny fragment planu, aby go skomentować."
     },

package/i18n/locales/tr.json

@@ -5465,11 +5465,12 @@
     },
     "planReview": {
       "title": "Bu plan sizi bekliyor",
-      "body": "Planlayıcı aşağıdaki aşamaları ve maddeleri hazırladı. Planı kaydedip işe başlamak için onaylayın ya da neyin değişmesi gerektiğini yazarak planı geri gönderin.",
+      "body": "Planlayıcı bu aşamaları ve maddeleri hazırladı. Planı kaydedip işe başlamak için onaylayın ya da neyin değişmesi gerektiğini yazarak planı geri gönderin.",
       "approve": "Planı onayla",
       "feedbackPlaceholder": "Planlayıcı neyi değiştirmeli? Kapsam, aşama sırası, eksik iş, başka yere ait bir madde…",
       "sendBack": "Planlayıcıya geri gönder",
-      "noDocument": "Bu plan, platform incelemeye yönelik planlar üretmeye başlamadan önce hazırlandı; gezinilecek bir belge yok — plan aşağıdaki bölümlerdir.",
+      "noDocument": "Bu planlama adımı incelenecek bir plan belgesi bırakmadı, bu yüzden burada gezinilecek bir şey yok.",
+      "noDocumentSections": "Plan aşağıdaki bölümlerdir.",
       "needsFeedback": "Önce bir yorum veya geri bildirim ekleyin — planlayıcı yeniden planlamak için bunu kullanır.",
       "commentHint": "Yorum yapmak için planın herhangi bir bölümüne tıklayın."
     },

package/i18n/locales/uk.json

@@ -5453,11 +5453,12 @@
     },
     "planReview": {
       "title": "Цей план чекає на вас",
-      "body": "Планувальник підготував фази та елементи нижче. Затвердіть їх, щоб зафіксувати план і розпочати роботу, або поверніть план із зазначенням, що змінити.",
+      "body": "Планувальник підготував ці фази та елементи. Затвердіть їх, щоб зафіксувати план і розпочати роботу, або поверніть план із зазначенням, що змінити.",
       "approve": "Затвердити план",
       "feedbackPlaceholder": "Що має змінити планувальник? Обсяг, порядок фаз, пропущена робота, елемент, якому місце деінде…",
       "sendBack": "Повернути планувальнику",
-      "noDocument": "Цей план склали до того, як платформа почала формувати плани для перегляду, тож документа для навігації немає — план становлять розділи нижче.",
+      "noDocument": "Цей крок планування не залишив документа плану для перегляду, тож тут немає чого оглядати.",
+      "noDocumentSections": "План становлять розділи нижче.",
       "needsFeedback": "Спершу додайте коментар або відгук — планувальник переплановує на його основі.",
       "commentHint": "Клацніть будь-яку частину плану, щоб залишити коментар."
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.195.0",
+  "version": "0.195.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",