@cat-factory/app 0.184.0 → 0.186.0

package/app/composables/useProseComments.ts

@@ -0,0 +1,126 @@
+import { computed, nextTick, ref, watch } from 'vue'
+import { sliceSource } from '~/utils/agentOutput'
+
+/** A draft per-block review comment, anchored to a source line range of the reviewed markdown. */
+export interface ProseComment {
+  srcStart: number
+  srcEnd: number
+  quotedSource: string
+  body: string
+}
+
+/**
+ * GitHub-style per-block commenting over a rendered markdown document — the anchoring half of a
+ * prose review, with no opinion about WHAT is being reviewed or how the review is submitted.
+ *
+ * Extracted from `useStepApproval` (which now builds on it) so a second surface can offer the
+ * same affordance: the initiative tracker's plan-approval rail reviews the planner's drafted plan,
+ * which the engine renders as markdown onto the gate's proposal. Both therefore anchor comments
+ * identically — a comment quotes the exact source lines of the block it targets, so a "request
+ * changes" re-run can hand the agent back its OWN text rather than a re-rendered approximation.
+ *
+ * The anchors are the `data-src-start`/`data-src-end` attributes `parseOutputOutline` stamps on
+ * every top-level block, so this works over any document that reader renders.
+ *
+ * @param output the raw markdown being reviewed (comments quote out of it by line range)
+ * @param root the element containing the rendered blocks, for the highlight sync
+ * @param enabled whether clicking a block should start a comment (review mode is on)
+ */
+export function useProseComments(opts: {
+  output: () => string
+  root: () => HTMLElement | null
+  enabled: () => boolean
+}) {
+  const comments = ref<ProseComment[]>([])
+  const draftTarget = ref<{ srcStart: number; srcEnd: number; quotedSource: string } | null>(null)
+  const draftBody = ref('')
+
+  const blockKey = (c: { srcStart: number; srcEnd: number }) => `${c.srcStart}:${c.srcEnd}`
+
+  /** Toggle the highlight classes on commented / selected blocks within the rendered document. */
+  function syncHighlights() {
+    const root = opts.root()
+    if (!root) return
+    const commented = new Set(comments.value.map(blockKey))
+    const selected = draftTarget.value ? blockKey(draftTarget.value) : null
+    for (const el of Array.from(root.querySelectorAll('[data-src-start]'))) {
+      const key = `${el.getAttribute('data-src-start')}:${el.getAttribute('data-src-end')}`
+      el.classList.toggle('cf-commented', commented.has(key))
+      el.classList.toggle('cf-selected', key === selected)
+    }
+  }
+
+  /** Click a rendered block to start commenting on it (links keep working). */
+  function onProseClick(e: MouseEvent) {
+    if (!opts.enabled()) return
+    const target = e.target as HTMLElement
+    if (target.closest('a')) return
+    const blockEl = target.closest('[data-src-start]') as HTMLElement | null
+    if (!blockEl) return
+    const srcStart = Number(blockEl.getAttribute('data-src-start'))
+    const srcEnd = Number(blockEl.getAttribute('data-src-end'))
+    if (Number.isNaN(srcStart) || Number.isNaN(srcEnd)) return
+    draftTarget.value = {
+      srcStart,
+      srcEnd,
+      quotedSource: sliceSource(opts.output(), srcStart, srcEnd),
+    }
+    draftBody.value = ''
+    void nextTick(syncHighlights)
+  }
+
+  function addDraftComment() {
+    if (!draftTarget.value || !draftBody.value.trim()) return
+    comments.value.push({ ...draftTarget.value, body: draftBody.value.trim() })
+    draftTarget.value = null
+    draftBody.value = ''
+    void nextTick(syncHighlights)
+  }
+  function cancelDraft() {
+    draftTarget.value = null
+    draftBody.value = ''
+    void nextTick(syncHighlights)
+  }
+  function removeComment(idx: number) {
+    comments.value.splice(idx, 1)
+    void nextTick(syncHighlights)
+  }
+
+  /** Drop every draft — a different document (or a different subject) is being reviewed. */
+  function reset() {
+    comments.value = []
+    draftTarget.value = null
+    draftBody.value = ''
+    void nextTick(syncHighlights)
+  }
+
+  /** The wire shape `requestStepChanges` takes, or undefined when nothing was anchored. */
+  const wireComments = computed(() =>
+    comments.value.length
+      ? comments.value.map((c) => ({
+          quotedSource: c.quotedSource,
+          srcStart: c.srcStart,
+          srcEnd: c.srcEnd,
+          body: c.body,
+        }))
+      : undefined,
+  )
+
+  // Keep the in-document highlights in sync as the document renders or the drafts change.
+  watch([opts.enabled, opts.output, comments, draftTarget], () => void nextTick(syncHighlights), {
+    deep: true,
+  })
+
+  return {
+    comments,
+    wireComments,
+    draftTarget,
+    draftBody,
+    syncHighlights,
+    onProseClick,
+    addDraftComment,
+    cancelDraft,
+    removeComment,
+    reset,
+  }
+}

package/app/composables/useStepApproval.ts

@@ -1,23 +1,17 @@
-import { ref, computed, nextTick, watch } from 'vue'
+import { ref, computed, nextTick } from 'vue'
 import type { PipelineStep } from '~/types/execution'
-import { sliceSource } from '~/utils/agentOutput'
-
-/** A draft per-block review comment, anchored to a source range of the output. */
-interface DraftComment {
-  srcStart: number
-  srcEnd: number
-  quotedSource: string
-  body: string
-}
+import { useProseComments } from '~/composables/useProseComments'
 
 /**
  * The GitHub-style approval/review state machine for a pending gate step. When the
  * step's gate is pending the prose reader doubles as a review surface: the human can
  * comment on individual source-mapped blocks, leave overall feedback, edit the
  * conclusions in place, then Approve / Request changes / Reject. This composable owns
- * all of that draft state + the in-document highlight syncing; the parent supplies the
- * live step, the scroll container (for highlight lookups), the run/approval ids, and a
- * `close` callback the actions invoke once they resolve.
+ * the approval-API half plus the edit/reject sub-states; the per-block comment drafts and
+ * their in-document highlighting live in {@link useProseComments}, which the initiative
+ * tracker's plan-approval rail shares. The parent supplies the live step, the scroll
+ * container (for highlight lookups), the run/approval ids, and a `close` callback the
+ * actions invoke once they resolve.
  */
 export function useStepApproval(opts: {
   step: () => PipelineStep | null
@@ -30,11 +24,8 @@ export function useStepApproval(opts: {
 }) {
   const execution = useExecutionStore()
 
-  const reviewComments = ref<DraftComment[]>([])
   const feedback = ref('')
   const submitting = ref(false)
-  const draftTarget = ref<{ srcStart: number; srcEnd: number; quotedSource: string } | null>(null)
-  const draftBody = ref('')
 
   // "Approve with corrections" mode: a deliberate state distinct from the read-only
   // review — the human edits the conclusions directly and those edits flow forward as
@@ -45,56 +36,25 @@ export function useStepApproval(opts: {
   // Reject stops the whole run, so it's a two-step inline confirm (no native dialog).
   const rejectArmed = ref(false)
 
-  const blockKey = (c: { srcStart: number; srcEnd: number }) => `${c.srcStart}:${c.srcEnd}`
-
-  /** Toggle the highlight classes on commented / selected blocks within the reader. */
-  function syncHighlights() {
-    const root = opts.scrollEl()
-    if (!root) return
-    const commented = new Set(reviewComments.value.map(blockKey))
-    const selected = draftTarget.value ? blockKey(draftTarget.value) : null
-    for (const el of Array.from(root.querySelectorAll('[data-src-start]'))) {
-      const key = `${el.getAttribute('data-src-start')}:${el.getAttribute('data-src-end')}`
-      el.classList.toggle('cf-commented', commented.has(key))
-      el.classList.toggle('cf-selected', key === selected)
-    }
-  }
-
-  /** Click a rendered block to start commenting on it (links keep working). */
-  function onProseClick(e: MouseEvent) {
-    if (!opts.approvalPending() || opts.companionExceeded() || editing.value) return
-    const target = e.target as HTMLElement
-    if (target.closest('a')) return
-    const blockEl = target.closest('[data-src-start]') as HTMLElement | null
-    if (!blockEl) return
-    const srcStart = Number(blockEl.getAttribute('data-src-start'))
-    const srcEnd = Number(blockEl.getAttribute('data-src-end'))
-    if (Number.isNaN(srcStart) || Number.isNaN(srcEnd)) return
-    draftTarget.value = {
-      srcStart,
-      srcEnd,
-      quotedSource: sliceSource(opts.step()?.output ?? '', srcStart, srcEnd),
-    }
-    draftBody.value = ''
-    void nextTick(syncHighlights)
-  }
-
-  function addDraftComment() {
-    if (!draftTarget.value || !draftBody.value.trim()) return
-    reviewComments.value.push({ ...draftTarget.value, body: draftBody.value.trim() })
-    draftTarget.value = null
-    draftBody.value = ''
-    void nextTick(syncHighlights)
-  }
-  function cancelDraft() {
-    draftTarget.value = null
-    draftBody.value = ''
-    void nextTick(syncHighlights)
-  }
-  function removeComment(idx: number) {
-    reviewComments.value.splice(idx, 1)
-    void nextTick(syncHighlights)
-  }
+  // The per-block comment drafts + their in-document highlights. Commenting is off while the
+  // human is in edit mode: the two paths are mutually exclusive, and the editor replaces the
+  // rendered document with a textarea, so there are no blocks to anchor to.
+  const prose = useProseComments({
+    output: () => opts.step()?.output ?? '',
+    root: () => opts.scrollEl(),
+    enabled: () => opts.approvalPending() && !opts.companionExceeded() && !editing.value,
+  })
+  const {
+    comments: reviewComments,
+    wireComments,
+    draftTarget,
+    draftBody,
+    syncHighlights,
+    onProseClick,
+    addDraftComment,
+    cancelDraft,
+    removeComment,
+  } = prose
 
   const canRequestChanges = computed(
     () => !!feedback.value.trim() || reviewComments.value.length > 0,
@@ -119,7 +79,7 @@ export function useStepApproval(opts: {
     editing.value = true
     // Editing and the review/reject path are mutually exclusive — clear the other.
     rejectArmed.value = false
-    draftTarget.value = null
+    prose.cancelDraft()
     void nextTick(syncHighlights)
   }
   function cancelEditing() {
@@ -143,14 +103,7 @@ export function useStepApproval(opts: {
     try {
       const ok = await execution.requestStepChanges(opts.instanceId()!, id, {
         feedback: feedback.value.trim() || undefined,
-        comments: reviewComments.value.length
-          ? reviewComments.value.map((c) => ({
-              quotedSource: c.quotedSource,
-              srcStart: c.srcStart,
-              srcEnd: c.srcEnd,
-              body: c.body,
-            }))
-          : undefined,
+        comments: wireComments.value,
       })
       if (ok) opts.close()
     } finally {
@@ -189,22 +142,13 @@ export function useStepApproval(opts: {
 
   /** Full reset of every draft when a different gate/step opens. */
   function resetForStep() {
-    reviewComments.value = []
+    prose.reset()
     feedback.value = ''
-    draftTarget.value = null
-    draftBody.value = ''
     rejectArmed.value = false
     editing.value = false
     draftProposal.value = ''
   }
 
-  // Keep the in-document highlights in sync as the output renders or comments change.
-  watch(
-    [opts.approvalPending, () => opts.step()?.output, reviewComments, draftTarget],
-    () => void nextTick(syncHighlights),
-    { deep: true },
-  )
-
   return {
     reviewComments,
     feedback,

package/app/composables/useStepProse.spec.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest'
+import { useStepProse } from './useStepProse'
+
+const DOC = ['# Plan', '', 'Intro.', '', '## Phase 1', '', 'First.', '', '## Phase 2', ''].join(
+  '\n',
+)
+
+/**
+ * A fake measurable element: the scroll-spy only ever reads `getBoundingClientRect().top`, so
+ * the vertical position is the whole of what a section is to it.
+ */
+function sectionAt(top: number): HTMLElement {
+  return { getBoundingClientRect: () => ({ top }) } as unknown as HTMLElement
+}
+
+describe('useStepProse scroll-spy', () => {
+  /**
+   * The reader's own layout: a details card ahead of the prose, which the consumer registers.
+   */
+  it('tracks the last anchor above the fold, lead section included', () => {
+    const prose = useStepProse(() => DOC)
+    prose.scrollEl.value = sectionAt(0)
+    const [first, second] = prose.tocSections.value
+    prose.sectionEls['step-details'] = sectionAt(-200)
+    prose.sectionEls[first!.id] = sectionAt(-100)
+    prose.sectionEls[second!.id] = sectionAt(400)
+
+    prose.onScroll()
+    expect(prose.activeId.value).toBe(first!.id)
+
+    // Scrolling on past the second heading moves the highlight to it.
+    prose.sectionEls[second!.id] = sectionAt(20)
+    prose.onScroll()
+    expect(prose.activeId.value).toBe(second!.id)
+  })
+
+  /**
+   * The regression this option exists for. A consumer that renders the document ALONE (the
+   * initiative tracker's plan-approval rail) never registers a lead anchor, and the spy walks
+   * anchors in document order and stops at the first one it cannot measure — so with the lead
+   * anchor hardcoded it stopped immediately, pinning `activeId` to a section that does not
+   * exist. Nothing threw; the ToC simply never highlighted anything, and any click-to-navigate
+   * highlight was wiped by the scroll event the smooth scroll itself fires.
+   */
+  it('tracks sections when the consumer renders no lead anchor', () => {
+    const prose = useStepProse(() => DOC, { leadAnchorId: null })
+    prose.scrollEl.value = sectionAt(0)
+    const [first, second] = prose.tocSections.value
+    prose.sectionEls[first!.id] = sectionAt(-100)
+    prose.sectionEls[second!.id] = sectionAt(400)
+
+    prose.onScroll()
+    expect(prose.activeId.value).toBe(first!.id)
+  })
+
+  it('starts on the lead anchor, or on nothing when there is none', () => {
+    expect(useStepProse(() => DOC).activeId.value).toBe('step-details')
+    expect(useStepProse(() => DOC, { leadAnchorId: null }).activeId.value).toBe('')
+  })
+
+  it('re-seeds the active anchor on reset', () => {
+    const prose = useStepProse(() => DOC, { leadAnchorId: null })
+    prose.activeId.value = 'somewhere'
+    prose.reset()
+    expect(prose.activeId.value).toBe('')
+  })
+})

package/app/composables/useStepProse.ts

@@ -4,23 +4,35 @@ import { parseOutputOutline } from '~/utils/agentOutput'
 /**
  * The prose reader for an agent step's markdown output: its heading outline, the
  * per-section collapse state, and the scroll-spy that keeps the ToC in sync.
- * Owns the scroll container + per-section element refs the template binds; the
- * details card is always the first anchor. `reset()` re-seeds (all sections
- * expanded, scrolled to top) whenever a different step opens.
+ * Owns the scroll container + per-section element refs the template binds.
+ * `reset()` re-seeds (all sections expanded, scrolled to top) whenever a different
+ * step opens.
+ *
+ * `leadAnchorId` names a section the CONSUMER renders ahead of the prose and registers in
+ * `sectionEls` — the step reader's details card. It is an option rather than a constant
+ * because the scroll-spy walks the anchors in document order and stops at the first one it
+ * cannot measure: a consumer that renders no such element (the initiative tracker's
+ * plan-approval rail, which has the document alone) would otherwise have its spy stop dead on
+ * an anchor that never exists, pinning `activeId` to a section nobody can see and leaving the
+ * ToC with nothing highlighted. Pass `null` when the prose is the whole document.
  */
-export function useStepProse(getOutput: () => string) {
+export function useStepProse(getOutput: () => string, opts: { leadAnchorId?: string | null } = {}) {
+  const leadAnchorId = opts.leadAnchorId === undefined ? 'step-details' : opts.leadAnchorId
   const outline = computed(() => parseOutputOutline(getOutput()))
   const tocSections = computed(() => outline.value.sections.filter((s) => s.depth > 0))
   const hasOutput = computed(() => !!getOutput().trim())
 
   const collapsed = reactive<Record<string, boolean>>({})
-  const activeId = ref<string>('step-details')
+  const activeId = ref<string>(leadAnchorId ?? '')
   const scrollEl = ref<HTMLElement | null>(null)
   const sectionEls = reactive<Record<string, HTMLElement | null>>({})
 
-  // Anchors the ToC navigates + the scroll-spy tracks: the details card first, then
-  // every heading section of the prose.
-  const anchors = computed(() => ['step-details', ...tocSections.value.map((s) => s.id)])
+  // Anchors the ToC navigates + the scroll-spy tracks: the lead section (when the consumer
+  // renders one) first, then every heading section of the prose.
+  const anchors = computed(() => [
+    ...(leadAnchorId ? [leadAnchorId] : []),
+    ...tocSections.value.map((s) => s.id),
+  ])
 
   function toggle(id: string) {
     collapsed[id] = !collapsed[id]
@@ -43,7 +55,7 @@ export function useStepProse(getOutput: () => string) {
     const container = scrollEl.value
     if (!container) return
     const line = container.getBoundingClientRect().top + 80
-    let current = anchors.value[0] ?? 'step-details'
+    let current = anchors.value[0] ?? ''
     for (const id of anchors.value) {
       const el = sectionEls[id]
       if (el && el.getBoundingClientRect().top <= line) current = id
@@ -55,7 +67,7 @@ export function useStepProse(getOutput: () => string) {
   // Re-seed (all sections expanded, scrolled to top) for a freshly-opened step.
   function reset() {
     for (const k of Object.keys(collapsed)) delete collapsed[k]
-    activeId.value = 'step-details'
+    activeId.value = leadAnchorId ?? ''
     void nextTick(() => scrollEl.value?.scrollTo({ top: 0 }))
   }
 

package/app/modular/nav-contributions.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import enCatalog from '../../i18n/locales/en.json'
+import { hasI18nKey } from '../../test/i18nKeys'
 import {
   groupCommands,
   groupSidebar,
@@ -10,18 +10,8 @@ import {
 } from './nav-contributions'
 import type { AppSlots, NavGates } from './nav-contributions'
 
-/** The layer's base i18n catalog, used to prove every referenced key resolves. */
-const en = enCatalog as Record<string, unknown>
-
-/** Walk a dotted vue-i18n key path; true when it resolves to a leaf string. */
-function hasKey(path: string): boolean {
-  let node: unknown = en
-  for (const part of path.split('.')) {
-    if (typeof node !== 'object' || node === null || !(part in node)) return false
-    node = (node as Record<string, unknown>)[part]
-  }
-  return typeof node === 'string'
-}
+/** Prove every referenced key resolves in the layer's base catalog (see `test/i18nKeys`). */
+const hasKey = hasI18nKey
 
 const NO_GATES: NavGates = {
   canWriteBoard: false,

package/app/modular/panels/inspector.logic.spec.ts

@@ -80,6 +80,13 @@ describe('inspector panel group', () => {
     expect(visibleIds(block('module'))).toEqual(['container-summary'])
   })
 
+  // The reviewed PR is the review task's SUBJECT, so it leads the body — above the context the
+  // task was given and the run that acts on it. Every other task type never sees the panel.
+  it('a review task leads with its review target', () => {
+    const review = { ...block('task'), taskType: 'review' } as Block
+    expect(visibleIds(review)[0]).toBe('task-review-target')
+  })
+
   it('a task shows the task body in the pre-slice-4 order', () => {
     expect(visibleIds(block('task'))).toEqual([
       'task-context-docs',

package/app/modular/panels/inspector.logic.ts

@@ -36,6 +36,7 @@ export const inspectorPanels = definePanelGroup<Block>(INSPECTOR_PANELS_SLOT)
  *  a silently-dropped panel). */
 export const INSPECTOR_PANEL_IDS = [
   // task body (rendered in this order under the identity block)
+  'task-review-target',
   'task-context-docs',
   'task-context-issues',
   'recurring-schedule',
@@ -119,6 +120,10 @@ const isDeployableFrame = (b: Block) => isFrame(b) && b.type !== 'document'
  * extensibility value.
  */
 export const INSPECTOR_PANEL_SPECS: readonly InspectorPanelSpec[] = [
+  // FIRST in the task body: for a review task the reviewed PR is what the task IS, so it reads
+  // above the context it was given and the run that acts on it. Gated on the task TYPE alone —
+  // the panel itself hides when the task carries no PR reference.
+  { id: 'task-review-target', order: 5, when: (b) => isTask(b) && b.taskType === 'review' },
   // Shared with the initiative body — an initiative takes the same attachments a task does.
   { id: 'task-context-docs', order: 10, when: takesContext },
   { id: 'task-context-issues', order: 20, when: takesContext },

package/app/modular/panels/inspector.ts

@@ -16,6 +16,7 @@ import TaskContextDocs from '~/components/documents/TaskContextDocs.vue'
 import TaskContextIssues from '~/components/tasks/TaskContextIssues.vue'
 import RecurringScheduleSettings from '~/components/panels/inspector/RecurringScheduleSettings.vue'
 import TaskExecution from '~/components/panels/inspector/TaskExecution.vue'
+import TaskReviewTarget from '~/components/panels/inspector/TaskReviewTarget.vue'
 import TaskEstimateBadge from '~/components/panels/inspector/TaskEstimateBadge.vue'
 import TaskDependencies from '~/components/panels/inspector/TaskDependencies.vue'
 import TaskRunSettings from '~/components/panels/inspector/TaskRunSettings.vue'
@@ -65,6 +66,7 @@ function blockPanel(component: Component, id: InspectorPanelId): PanelComponent
 /** Exhaustive id → sub-panel map. Typed `Record<InspectorPanelId, …>` so adding a
  *  spec without a component (or vice-versa) fails the typecheck. */
 const COMPONENTS: Record<InspectorPanelId, Component> = {
+  'task-review-target': TaskReviewTarget,
   'task-context-docs': TaskContextDocs,
   'task-context-issues': TaskContextIssues,
   'recurring-schedule': RecurringScheduleSettings,

package/app/stores/execution.ts

@@ -188,6 +188,14 @@ export const useExecutionStore = defineStore('execution', () => {
       blockId: string
       approval: StepApproval
       agentKind: PipelineStep['agentKind']
+      /**
+       * Whether the gate's proposal is a RENDERING of an artifact the step already committed
+       * (`step.outputIsRendered`). Projected here because a surface that reviews the proposal
+       * WITHOUT the step in hand — the initiative tracker's plan-approval rail — otherwise has
+       * no way to tell a rendered document from the agent's raw transcript summary, and would
+       * present a one-line summary as though it were the artifact.
+       */
+      outputIsRendered: boolean
     }[] = []
     for (const e of instances.value) {
       for (const s of e.steps) {
@@ -197,6 +205,7 @@ export const useExecutionStore = defineStore('execution', () => {
             blockId: e.blockId,
             approval: s.approval,
             agentKind: s.agentKind,
+            outputIsRendered: s.outputIsRendered === true,
           })
         }
       }

package/app/stores/validationChecks.ts

@@ -86,21 +86,25 @@ export const useValidationChecksStore = defineStore('validationChecks', () => {
   }
 
   /**
-   * Save a service frame's checks. An EMPTY list clears the config on the backend (the service
-   * deletes the row), which restores the exact pre-feature behaviour — so the local list drops
-   * the entry rather than keeping an empty one that reads as "configured".
+   * Save a service frame's checks and its dependency-prepopulation install. The backend deletes
+   * the row only when BOTH are empty (restoring the exact pre-feature behaviour), so the local
+   * list mirrors that rule — dropping the entry on an empty save of both, and keeping it for a
+   * service that declares only an install. Testing `checks` alone here would evict a live
+   * install-only config from the store and report the service as unconfigured until a reload.
    */
   async function save(
     blockId: string,
     checks: ValidationCheck[],
     maxAttempts: number,
+    dependencyInstall?: string,
   ): Promise<void> {
     const ws = useWorkspaceStore()
     const saved = await api.setServiceValidationConfig(ws.requireId(), blockId, {
       checks,
       maxAttempts,
+      ...(dependencyInstall ? { dependencyInstall } : {}),
     })
-    if (saved.checks.length === 0) dropLocal(blockId)
+    if (saved.checks.length === 0 && !saved.dependencyInstall) dropLocal(blockId)
     else upsertLocal(saved)
   }
 

package/app/utils/initiative.spec.ts

@@ -1,7 +1,11 @@
 import { INITIATIVE_ITEM_TERMINAL_STATUSES } from '@cat-factory/contracts'
 import { describe, it, expect } from 'vitest'
 import type { InitiativeItem, InitiativePhase, InitiativeQa } from '~/types/domain'
+import { missingI18nKeys } from '../../test/i18nKeys'
 import {
+  INITIATIVE_ATTENTION_LABEL_KEYS,
+  INITIATIVE_FOLLOWUP_STATUS_LABEL_KEYS,
+  INITIATIVE_STATUS_LABEL_KEYS,
   isPendingQuestion,
   orderInterviewQuestions,
   pendingCheckpointPhase,
@@ -200,3 +204,23 @@ describe('selectPlanApproval', () => {
     expect(selectPlanApproval(approvals, resultViewOf)?.approval.id).toBe('ap_custom')
   })
 })
+
+/**
+ * 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
+ * `i18n:check` only see a key written literally at a `t()` call site, while the exhaustive
+ * `Record` only proves every enum MEMBER has an entry — never that the entry still names a key
+ * the catalog holds. Without this, deleting a key reads as a clean removal and the affordance
+ * renders its own key path to the user.
+ */
+describe('the initiative label-key tables', () => {
+  it('name keys the base catalog actually holds', () => {
+    expect(
+      missingI18nKeys([
+        ...Object.values(INITIATIVE_ATTENTION_LABEL_KEYS),
+        ...Object.values(INITIATIVE_STATUS_LABEL_KEYS),
+        ...Object.values(INITIATIVE_FOLLOWUP_STATUS_LABEL_KEYS),
+      ]),
+    ).toEqual([])
+  })
+})

package/i18n/locales/de.json

@@ -1285,6 +1285,12 @@
       "risk": "Risiko",
       "impact": "Wirkung"
     },
+    "reviewTarget": {
+      "title": "Geprüfter Pull Request",
+      "hint": "Der bestehende Pull Request, den diese Aufgabe prüft.",
+      "prNumber": "PR #{number}",
+      "focus": "Schwerpunkt: {focus}"
+    },
     "execution": {
       "title": "Ausführung",
       "hint": "Der Live-Lauf der Pipeline: jeder Agent-Schritt, sein Fortschritt und der resultierende Pull Request.",
@@ -1433,6 +1439,8 @@
     "validationChecks": {
       "title": "Prüfungen vor dem PR",
       "sectionHint": "Befehle, die nach dem Coder und vor dem Öffnen eines Pull Requests im Checkout laufen. Ein Fehlschlag geht zur Behebung an den Agenten zurück; nur ein fehlerfreier Checkout öffnet einen PR.",
+      "dependencyInstall": "Abhängigkeiten installieren",
+      "dependencyInstallHint": "Läuft, bevor der Agent startet",
       "hint": "Jeder Befehl läuft der Reihe nach mit `sh -c` im Checkout dieses Dienstes. Der Agent soll den Code reparieren, nicht die Prüfung abschwächen.",
       "clear": "Leeren",
       "configNoun": "Prüfungen",
@@ -1452,6 +1460,7 @@
         "action": "Erkennen",
         "hint": "Prüfungen aus dem Repository dieses Dienstes vorschlagen",
         "added": "{count} Prüfung hinzugefügt | {count} Prüfungen hinzugefügt",
+        "installOnly": "Abhängigkeitsinstallation eingetragen",
         "found": "Erkannt: {ecosystems}.",
         "capped": "Einige Vorschläge wurden ausgelassen — ein Dienst nimmt höchstens {max} Prüfungen auf.",
         "nothingNew": "Nichts hinzuzufügen",
@@ -1622,6 +1631,7 @@
       "editConclusionsPlaceholder": "Bearbeite die Schlussfolgerungen des Agents; deine Änderungen werden bei der Freigabe gespeichert…",
       "noProseOutput": "Dieser Agent hat keine Prosa-Ausgabe erzeugt.",
       "approveWithCorrections": "Mit Korrekturen freigeben",
+      "renderedOutputNote": "Diese Ausgabe ist eine Darstellung dessen, was der Schritt erzeugt hat, und kann hier nicht bearbeitet werden. Fordere Änderungen an, um sie überarbeiten zu lassen.",
       "reviewAndApprove": "Prüfen & freigeben",
       "editHint": "Bearbeite die Schlussfolgerungen links; deine Änderungen werden bei der Freigabe gespeichert.",
       "reviewHint": "Klicke auf einen beliebigen Block in der Ausgabe, um ihn zu kommentieren, oder hinterlasse unten allgemeines Feedback.",
@@ -2421,7 +2431,9 @@
         "focus": "Prüfungsschwerpunkt",
         "focusPlaceholder": "z. B. Fokus auf die Auth-Änderungen und Fehlerbehandlung",
         "derivedTitle": "{ref} prüfen",
-        "derivedTitleFallback": "Pull Request prüfen"
+        "derivedTitleFallback": "Pull Request prüfen",
+        "prNotFound": "Pull Request #{number} wurde im Repository dieses Service nicht gefunden. Prüfe die Nummer, oder verknüpfe den Service mit dem Repository, in dem der Pull Request liegt.",
+        "prRepoMismatch": "Dieser Pull Request liegt in einem anderen Repository. Dieser Service prüft {repo}; lege die Prüfaufgabe unter dem Service an, der mit dem Repository des Pull Requests verknüpft ist."
       }
     },
     "recurring": {
@@ -4329,9 +4341,11 @@
       "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.",
       "approve": "Plan freigeben",
-      "requestChanges": "Änderungen anfordern",
       "feedbackPlaceholder": "Was soll der Planner ändern? Umfang, Reihenfolge der Phasen, fehlende Arbeit, eine Aufgabe, die woanders hingehört …",
-      "sendBack": "An den Planner zurückschicken"
+      "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.",
+      "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."
     },
     "planning": {
       "title": "Die Initiative planen",