@cat-factory/app 0.108.1 → 0.109.2

package/app/components/board/nodes/InitiativeCard.vue

@@ -1,11 +1,15 @@
 <script setup lang="ts">
 // The board card for an `initiative`-level block (a frame child, like a module):
 // title, the initiative's lifecycle status, and — once a plan is ingested — the
-// item-completion progress. Clicking selects the block (the inspector offers
-// "Run planning" / "Open tracker"); the tracker button opens the dedicated
-// window directly. Draggable within its frame like a task card.
+// item-completion progress. Mirrors a task card's on-card "Start" affordance: the
+// initiative's equivalent "Run planning" (and, while parked mid-interview, "Answer
+// planning questions") lives right here on the board — the same actions the
+// inspector offers — so starting an initiative isn't hidden behind selecting it.
+// The tracker button opens the dedicated window directly. Draggable within its
+// frame like a task card.
 import type { InitiativeStatus } from '~/types/domain'
 import { useBlockDrag } from '~/composables/useBlockDrag'
+import { useInitiativePlanning } from '~/composables/useInitiativePlanning'
 import {
   INITIATIVE_STATUS_CHIPS,
   INITIATIVE_STATUS_LABEL_KEYS,
@@ -29,13 +33,21 @@ const progress = computed(() => initiativeProgress(initiative.value?.items))
 
 const selected = computed(() => ui.selectedBlockId === props.blockId)
 
+// The "Run planning" / "Answer planning questions" affordances, shared with the inspector so the
+// board card and inspector can't drift (see {@link useInitiativePlanning}).
+const {
+  planningPipeline,
+  running,
+  awaitingAnswers,
+  starting,
+  runPlanning,
+  openPlanning,
+  openTracker,
+} = useInitiativePlanning(() => props.blockId)
+
 function select() {
   ui.select(props.blockId)
 }
-function openTracker() {
-  ui.select(props.blockId)
-  ui.openInitiativeTracker(props.blockId)
-}
 function onHandle(e: PointerEvent) {
   if (block.value) startDrag(block.value, e)
 }
@@ -65,7 +77,7 @@ function onHandle(e: PointerEvent) {
     <div
       data-testid="initiative-card"
       class="cursor-pointer rounded-b-lg border border-indigo-800/60 bg-indigo-950/40 p-3 transition hover:border-indigo-600"
-      :class="selected ? 'ring-2 ring-indigo-400/60' : ''"
+      :class="[selected ? 'ring-2 ring-indigo-400/60' : '', awaitingAnswers ? 'board-pulse' : '']"
       @click.stop="select"
     >
       <div class="flex items-start justify-between gap-2">
@@ -91,17 +103,43 @@ function onHandle(e: PointerEvent) {
           {{ t('initiative.card.progress', { done: progress.settled, total: progress.total }) }}
         </div>
       </div>
-      <UButton
-        class="nodrag mt-2"
-        data-testid="initiative-open-tracker"
-        size="xs"
-        variant="soft"
-        color="primary"
-        icon="i-lucide-list-checks"
-        @click.stop="openTracker"
-      >
-        {{ t('initiative.card.openTracker') }}
-      </UButton>
+      <div class="nodrag mt-2 flex flex-wrap items-center gap-1">
+        <UButton
+          v-if="awaitingAnswers"
+          data-testid="initiative-card-answer-planning"
+          size="xs"
+          variant="solid"
+          color="primary"
+          icon="i-lucide-messages-square"
+          @click.stop="openPlanning"
+        >
+          {{ t('initiative.inspector.answerPlanning') }}
+        </UButton>
+        <UButton
+          v-else
+          data-testid="initiative-card-run-planning"
+          size="xs"
+          variant="soft"
+          color="primary"
+          icon="i-lucide-play"
+          :loading="starting || running"
+          :disabled="!planningPipeline || running || starting"
+          :title="t('initiative.inspector.runPlanning')"
+          @click.stop="runPlanning"
+        >
+          {{ t('initiative.inspector.runPlanning') }}
+        </UButton>
+        <UButton
+          data-testid="initiative-open-tracker"
+          size="xs"
+          variant="soft"
+          color="neutral"
+          icon="i-lucide-list-checks"
+          @click.stop="openTracker"
+        >
+          {{ t('initiative.card.openTracker') }}
+        </UButton>
+      </div>
     </div>
   </div>
 </template>

package/app/components/common/ClarificationItem.vue

@@ -0,0 +1,158 @@
+<script setup lang="ts">
+// Shared "clarification item" — the per-prompt answer surface reused by the initiative-planning
+// window and (incrementally) the requirements-review window, so the two ask/answer/dismiss/recommend
+// UIs are ONE component rather than parallel clones. See docs/initiatives/clarification-items.md.
+//
+// It renders a prompt, an answer textarea, and the common actions (Not relevant / Recommend), plus
+// a dismissed→reopen state and an optional inline AI suggestion with "Use this answer". Window
+// -specific extras (severity/category badges, a window's own recommendation section) ride the
+// `badges` / `actions` slots; the recommend button only EMITS, so each window wires its own
+// recommend mechanism. `dismissed`/`requested` hide the textarea (nothing to answer right now).
+const props = defineProps<{
+  /** The question / finding headline. */
+  prompt: string
+  /** Optional longer prose under the prompt (e.g. a requirements finding's detail). */
+  detail?: string
+  /** The editable answer draft (v-model). Undefined is treated as empty. */
+  answer?: string
+  /** The human marked this not-relevant → show a chip + Reopen instead of the answer box. */
+  dismissed?: boolean
+  /** A recommendation is being generated for this item → hide the box, show a working chip. */
+  requested?: boolean
+  /** An AI-suggested answer to offer inline, or null/undefined for none. */
+  recommendation?: string | null
+  /** A recommend request is in flight for THIS item (button spinner). */
+  recommending?: boolean
+  /** Freeze all inputs/actions (settled / background cycle running). */
+  disabled?: boolean
+  /** Placeholder for the answer box; defaults to the shared clarification placeholder. */
+  answerPlaceholder?: string
+  /** Show the Recommend action (needs a wired model). Default true. */
+  canRecommend?: boolean
+}>()
+
+const emit = defineEmits<{
+  'update:answer': [value: string]
+  persist: []
+  dismiss: []
+  reopen: []
+  recommend: []
+  useRecommendation: []
+}>()
+
+const { t } = useI18n()
+
+const draft = computed({
+  get: () => props.answer ?? '',
+  set: (value: string) => emit('update:answer', value),
+})
+</script>
+
+<template>
+  <div
+    class="rounded-lg border border-slate-800 bg-slate-950/40 p-3"
+    data-testid="clarification-item"
+  >
+    <div class="flex items-start justify-between gap-2">
+      <p class="text-[13px] font-medium text-slate-200">{{ prompt }}</p>
+      <slot name="badges" />
+    </div>
+    <p v-if="detail" class="mt-1 whitespace-pre-wrap text-[12px] leading-relaxed text-slate-400">
+      {{ detail }}
+    </p>
+
+    <!-- dismissed: a "not relevant" chip + reopen -->
+    <div v-if="dismissed" class="mt-2 flex items-center justify-between gap-2">
+      <span class="inline-flex items-center gap-1 text-[11px] text-slate-500">
+        <UIcon name="i-lucide-x" class="h-3.5 w-3.5" />{{ t('clarification.dismissed') }}
+      </span>
+      <UButton
+        size="xs"
+        variant="ghost"
+        color="neutral"
+        icon="i-lucide-rotate-ccw"
+        data-testid="clarification-reopen"
+        :disabled="disabled"
+        @click="emit('reopen')"
+      >
+        {{ t('clarification.reopen') }}
+      </UButton>
+    </div>
+
+    <!-- a recommendation is being requested/generated: a working chip, no answer box -->
+    <div
+      v-else-if="requested"
+      class="mt-2 inline-flex items-center gap-1 text-[11px] text-indigo-300"
+      data-testid="clarification-requested"
+    >
+      <UIcon name="i-lucide-loader-circle" class="h-3.5 w-3.5 animate-spin" />
+      {{ t('clarification.generating') }}
+    </div>
+
+    <template v-else>
+      <UTextarea
+        v-model="draft"
+        :rows="2"
+        autoresize
+        :disabled="disabled"
+        :placeholder="answerPlaceholder ?? t('clarification.answerPlaceholder')"
+        class="mt-2 w-full"
+        data-testid="clarification-answer"
+        @blur="emit('persist')"
+      />
+      <div class="mt-2 flex flex-wrap items-center gap-1">
+        <UButton
+          size="xs"
+          variant="soft"
+          color="neutral"
+          icon="i-lucide-x"
+          data-testid="clarification-dismiss"
+          :disabled="disabled"
+          @click="emit('dismiss')"
+        >
+          {{ t('clarification.notRelevant') }}
+        </UButton>
+        <UButton
+          v-if="canRecommend !== false"
+          size="xs"
+          variant="soft"
+          color="primary"
+          icon="i-lucide-wand-2"
+          data-testid="clarification-recommend"
+          :loading="recommending"
+          :disabled="disabled || recommending"
+          @click="emit('recommend')"
+        >
+          {{ t('clarification.recommend') }}
+        </UButton>
+        <slot name="actions" />
+      </div>
+
+      <!-- inline AI suggestion + "use this answer" -->
+      <div
+        v-if="recommendation"
+        class="mt-2 rounded-md border border-indigo-800/50 bg-indigo-950/30 p-2"
+        data-testid="clarification-recommendation"
+      >
+        <div
+          class="mb-1 flex items-center gap-1 text-[10px] uppercase tracking-wide text-indigo-300"
+        >
+          <UIcon name="i-lucide-wand-2" class="h-3 w-3" />{{ t('clarification.suggestion') }}
+        </div>
+        <p class="whitespace-pre-wrap text-[12px] text-slate-200">{{ recommendation }}</p>
+        <UButton
+          class="mt-1.5"
+          size="xs"
+          variant="soft"
+          color="primary"
+          icon="i-lucide-check"
+          data-testid="clarification-use-recommendation"
+          :disabled="disabled"
+          @click="emit('useRecommendation')"
+        >
+          {{ t('clarification.useSuggestion') }}
+        </UButton>
+      </div>
+    </template>
+  </div>
+</template>

package/app/components/initiative/InitiativePlanningWindow.vue

@@ -8,6 +8,7 @@
 // (`ui.openInitiativePlanning`) or as the interviewer step's result view. Live `initiative`
 // stream events patch the store, so an open window follows the interview as it progresses.
 import { computed, reactive, watch } from 'vue'
+import ClarificationItem from '~/components/common/ClarificationItem.vue'
 import { INITIATIVE_STATUS_LABEL_KEYS } from '~/utils/initiative'
 
 const board = useBoardStore()
@@ -25,7 +26,10 @@ const initiative = computed(() => (blockId.value ? initiatives.forBlock(blockId.
 const questions = computed(() =>
   (initiative.value?.qa ?? []).map((q, i) => ({ ...q, key: q.id ?? `q-${i}` })),
 )
-const pending = computed(() => questions.value.filter((q) => !(q.answer ?? '').trim()))
+/** Questions still needing an answer: not dismissed, and not yet answered (mirrors backend). */
+const pending = computed(() =>
+  questions.value.filter((q) => q.status !== 'dismissed' && !(q.answer ?? '').trim()),
+)
 /** The interview converged (or never started with a model): nothing left to answer. */
 const converged = computed(() => initiative.value?.interview?.status === 'done')
 
@@ -43,18 +47,50 @@ watch(
 )
 
 const resuming = computed(() => initiatives.resuming)
-/** Continue is meaningful once every pending question has a drafted answer. */
+/**
+ * Continue is meaningful once every pending question has a drafted answer. A dismissed question
+ * doesn't count (it was set aside), so an all-dismissed round is trivially "answered".
+ */
 const allAnswered = computed(() => pending.value.every((q) => drafts[q.key]?.trim()))
 
-/** Persist one answer if its draft differs from what's recorded. */
-async function persist(q: { id?: string; key: string; answer?: string }) {
+/**
+ * Persist one answer if its draft differs from what's recorded. A `dismissed` question is skipped:
+ * it was set aside (its server answer cleared), and the `flushThen` sweep on continue/proceed must
+ * NOT write a stale local draft back to it — that would silently re-answer a not-relevant question
+ * and leak it into the converged digest.
+ */
+async function persist(q: {
+  id?: string
+  key: string
+  answer?: string
+  status?: 'open' | 'dismissed'
+}) {
   const id = q.id
-  if (!id || !blockId.value) return
+  if (!id || !blockId.value || q.status === 'dismissed') return
   const next = (drafts[q.key] ?? '').trim()
   if (!next || next === (q.answer ?? '').trim()) return
   await initiatives.answerQuestion(blockId.value, id, next)
 }
 
+/** Mark a question not-relevant / reopen it. */
+async function setStatus(q: { id?: string }, status: 'open' | 'dismissed') {
+  if (!q.id || !blockId.value) return
+  await initiatives.setQuestionStatus(blockId.value, q.id, status)
+}
+
+/** Ask the interviewer to draft a suggested answer for this question. */
+async function recommend(q: { id?: string }) {
+  if (!q.id || !blockId.value) return
+  await initiatives.recommendAnswer(blockId.value, q.id)
+}
+
+/** Adopt a suggested answer into the draft, then persist it. */
+async function useRecommendation(q: { id?: string; key: string; recommendation?: string | null }) {
+  if (!q.recommendation) return
+  drafts[q.key] = q.recommendation
+  await persist(q)
+}
+
 /** Flush all dirty drafts, then run a window action (continue / proceed). */
 async function flushThen(action: (id: string) => Promise<unknown>) {
   if (!blockId.value) return
@@ -129,23 +165,22 @@ const onProceed = () => flushThen((id) => initiatives.proceedPlanning(id))
               {{ t('initiative.planning.converged') }}
             </div>
 
-            <!-- Interview questions -->
+            <!-- Interview questions — the shared clarification surface (answer / not-relevant /
+                 recommend), reused with the requirements-review window. -->
             <ul v-else class="space-y-4">
-              <li
-                v-for="q in questions"
-                :key="q.key"
-                class="rounded-lg border border-slate-800 bg-slate-950/40 p-3"
-                data-testid="initiative-planning-question"
-              >
-                <p class="mb-2 text-[13px] font-medium text-slate-200">{{ q.question }}</p>
-                <UTextarea
-                  v-model="drafts[q.key]"
-                  :rows="2"
-                  autoresize
-                  :placeholder="t('initiative.planning.answerPlaceholder')"
-                  class="w-full"
-                  data-testid="initiative-planning-answer"
-                  @blur="persist(q)"
+              <li v-for="q in questions" :key="q.key" data-testid="initiative-planning-question">
+                <ClarificationItem
+                  v-model:answer="drafts[q.key]"
+                  :prompt="q.question"
+                  :dismissed="q.status === 'dismissed'"
+                  :recommendation="q.recommendation"
+                  :recommending="!!q.id && initiatives.recommending.has(q.id)"
+                  :answer-placeholder="t('initiative.planning.answerPlaceholder')"
+                  @persist="persist(q)"
+                  @dismiss="setStatus(q, 'dismissed')"
+                  @reopen="setStatus(q, 'open')"
+                  @recommend="recommend(q)"
+                  @use-recommendation="useRecommendation(q)"
                 />
               </li>
             </ul>

package/app/components/panels/inspector/InitiativeInspector.vue

@@ -5,47 +5,29 @@
 // cancel once executing), and the tracker window opener. Plan/policy editing lands
 // with slice 4.
 import type { Block, InitiativeStatus } from '~/types/domain'
+import { useInitiativePlanning } from '~/composables/useInitiativePlanning'
 import { INITIATIVE_STATUS_LABEL_KEYS, initiativeProgress } from '~/utils/initiative'
 
 const props = defineProps<{ block: Block }>()
 
 const initiatives = useInitiativesStore()
-const pipelines = usePipelinesStore()
-const execution = useExecutionStore()
-const ui = useUiStore()
 const { t } = useI18n()
 
 const initiative = computed(() => initiatives.forBlock(props.block.id))
 
 const status = computed<InitiativeStatus>(() => initiative.value?.status ?? 'planning')
 
-// The planning pipeline runnable on this initiative block: its preset descriptor's
-// `planningPipelineId` (a preset picks its own planning pipeline — the generic preset keeps
-// `pl_initiative`). `planningPipelineIdFor` returns null for a named preset that hasn't hydrated,
-// so "Run planning" stays disabled rather than launching the wrong (generic interviewer) pipeline.
-// The engine's runnable guard still enforces that only an initiative-shaped pipeline runs here.
-const planningPipeline = computed(() => {
-  const id = initiatives.planningPipelineIdFor(initiative.value)
-  return id ? pipelines.pipelines.find((p) => p.id === id) : undefined
-})
-const running = computed(() => !!props.block.executionId)
-
-// The interviewer has parked the planning run with questions awaiting answers.
-const awaitingAnswers = computed(
-  () =>
-    initiative.value?.interview?.status === 'awaiting' &&
-    (initiative.value?.qa ?? []).some((q) => !(q.answer ?? '').trim()),
-)
-
-function runPlanning() {
-  if (planningPipeline.value) void execution.start(props.block.id, planningPipeline.value)
-}
-function openTracker() {
-  ui.openInitiativeTracker(props.block.id)
-}
-function openPlanning() {
-  ui.openInitiativePlanning(props.block.id)
-}
+// The "Run planning" / "Answer planning questions" affordances, shared with the board card so the
+// two surfaces can't drift (see {@link useInitiativePlanning}).
+const {
+  planningPipeline,
+  running,
+  awaitingAnswers,
+  starting,
+  runPlanning,
+  openPlanning,
+  openTracker,
+} = useInitiativePlanning(() => props.block.id)
 
 const progress = computed(() => initiativeProgress(initiative.value?.items))
 
@@ -90,7 +72,8 @@ function control(action: 'pause' | 'resume' | 'cancel') {
         variant="soft"
         size="sm"
         icon="i-lucide-play"
-        :disabled="!planningPipeline || running"
+        :loading="starting || running"
+        :disabled="!planningPipeline || running || starting"
         @click="runPlanning"
       >
         {{ t('initiative.inspector.runPlanning') }}

package/app/composables/api/initiative.ts

@@ -11,13 +11,16 @@ import {
   probeInitiativePresetContract,
   proceedInitiativePlanningContract,
   promoteInitiativeFollowUpContract,
+  recommendInitiativeAnswerContract,
   resumeInitiativeContract,
+  setInitiativeQuestionStatusContract,
   updateInitiativeItemContract,
   updateInitiativePolicyContract,
 } from '@cat-factory/contracts'
 import type {
   InitiativeExecutionPolicy,
   InitiativePresetInputs,
+  InitiativeQaStatus,
   PromoteInitiativeFollowUpInput,
   UpdateInitiativeItemInput,
 } from '@cat-factory/contracts'
@@ -74,6 +77,27 @@ export function initiativeApi({ send, ws }: ApiContext) {
         body: { questionId, answer },
       }),
 
+    // Mark a planning question not-relevant (`dismissed`) or reopen it, and ask the interviewer to
+    // recommend a suggested answer for one question. Both mutate the entity without resuming the run.
+    setInitiativeQuestionStatus: (
+      workspaceId: string,
+      blockId: string,
+      questionId: string,
+      status: InitiativeQaStatus,
+    ) =>
+      send(setInitiativeQuestionStatusContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
+        body: { questionId, status },
+      }),
+
+    recommendInitiativeAnswer: (workspaceId: string, blockId: string, questionId: string) =>
+      send(recommendInitiativeAnswerContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
+        body: { questionId },
+      }),
+
     continueInitiativePlanning: (workspaceId: string, blockId: string) =>
       send(continueInitiativePlanningContract, {
         pathPrefix: ws(workspaceId),

package/app/composables/useInitiativePlanning.ts

@@ -0,0 +1,91 @@
+import { computed, ref, toValue, watch, type MaybeRefOrGetter } from 'vue'
+import { useBoardStore } from '~/stores/board'
+import { useExecutionStore } from '~/stores/execution'
+import { useInitiativesStore } from '~/stores/initiative'
+import { usePipelinesStore } from '~/stores/pipelines'
+import { useUiStore } from '~/stores/ui'
+
+/**
+ * Shared planning affordances for an `initiative`-level block, used by BOTH the board card
+ * (`InitiativeCard`) and the inspector (`InitiativeInspector`) so the two surfaces can never drift
+ * on WHICH pipeline "Run planning" starts, WHEN the interview is awaiting the human, or the
+ * optimistic start state. Keyed by the anchor block id; every value is reactive to the
+ * board/initiative stores. Mirrors the repo's other extracted per-block composables
+ * (`useReviewStage`, `useBlockQueries`).
+ */
+export function useInitiativePlanning(blockId: MaybeRefOrGetter<string>) {
+  const board = useBoardStore()
+  const initiatives = useInitiativesStore()
+  const pipelines = usePipelinesStore()
+  const execution = useExecutionStore()
+  const ui = useUiStore()
+
+  const block = computed(() => board.getBlock(toValue(blockId)))
+  const initiative = computed(() => initiatives.forBlock(toValue(blockId)))
+
+  // The planning pipeline runnable on this block: its preset descriptor's `planningPipelineId`
+  // (the generic preset keeps `pl_initiative`). `planningPipelineIdFor` returns null for a named
+  // preset that hasn't hydrated, so "Run planning" stays disabled rather than launching the wrong
+  // (generic interviewer) pipeline. The engine's runnable guard still enforces that only an
+  // initiative-shaped pipeline runs here.
+  const planningPipeline = computed(() => {
+    const id = initiatives.planningPipelineIdFor(initiative.value)
+    return id ? pipelines.pipelines.find((p) => p.id === id) : undefined
+  })
+
+  /** A run already owns this block (its planning run's id lingers on the block). */
+  const running = computed(() => !!block.value?.executionId)
+
+  /**
+   * The interviewer has PARKED the planning run for the human. Keyed purely on the interview's
+   * parked `status` (`awaiting`) — NOT on whether individual questions are still blank — so the
+   * "Answer planning questions" affordance stays available even after every question is filled but
+   * before the human resumes. Gating on unanswered questions would hide the only path back to the
+   * interview window once all are answered, stranding the still-parked run.
+   */
+  const awaitingAnswers = computed(() => initiative.value?.interview?.status === 'awaiting')
+
+  /**
+   * Optimistic start flag: flip true the instant "Run planning" is clicked, before the stream
+   * pushes the block's `executionId` back. Cleared the moment `running` takes over (success) or the
+   * start is refused/cancelled — never left dangling, which would otherwise strand the button
+   * spinning once `running` later clears (e.g. after a cancel returns the block to `planned`).
+   */
+  const starting = ref(false)
+  watch(running, (isRunning) => {
+    if (isRunning) starting.value = false
+  })
+
+  async function runPlanning() {
+    if (!planningPipeline.value || running.value || starting.value) return
+    starting.value = true
+    const started = await execution.start(toValue(blockId), planningPipeline.value)
+    // On success `running` flips true and the watcher clears `starting`; on refusal/cancel the
+    // store surfaces its own toast, so just revert the optimistic state here.
+    if (!started) starting.value = false
+  }
+
+  /** Open the planning/interview window (selecting the block first so the inspector follows). */
+  function openPlanning() {
+    const id = toValue(blockId)
+    ui.select(id)
+    ui.openInitiativePlanning(id)
+  }
+
+  /** Open the initiative's tracker window (selecting the block first). */
+  function openTracker() {
+    const id = toValue(blockId)
+    ui.select(id)
+    ui.openInitiativeTracker(id)
+  }
+
+  return {
+    planningPipeline,
+    running,
+    awaitingAnswers,
+    starting,
+    runPlanning,
+    openPlanning,
+    openTracker,
+  }
+}

package/app/stores/initiative.ts

@@ -181,6 +181,49 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     return updated
   }
 
+  /** Question ids the interviewer is currently drafting a recommendation for (window spinner). */
+  const recommending = ref<Set<string>>(new Set())
+
+  /** Mark a planning question not-relevant (`dismissed`) or reopen it (no run resume). */
+  async function setQuestionStatus(
+    blockId: string,
+    questionId: string,
+    status: 'open' | 'dismissed',
+  ) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    const updated = await api.setInitiativeQuestionStatus(
+      workspace.workspaceId,
+      blockId,
+      questionId,
+      status,
+    )
+    upsert(updated)
+    return updated
+  }
+
+  /**
+   * Ask the interviewer to recommend a suggested answer for one pending question. Runs the
+   * interviewer LLM inline server-side; the returned entity carries the suggestion on the question.
+   * Tracks the in-flight id so the window can show a per-question spinner.
+   */
+  async function recommendAnswer(blockId: string, questionId: string) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    recommending.value = new Set(recommending.value).add(questionId)
+    try {
+      const updated = await api.recommendInitiativeAnswer(
+        workspace.workspaceId,
+        blockId,
+        questionId,
+      )
+      upsert(updated)
+      return updated
+    } finally {
+      const next = new Set(recommending.value)
+      next.delete(questionId)
+      recommending.value = next
+    }
+  }
+
   /** Submit the answers and resume the interview (the interviewer re-runs, may ask more). */
   async function continuePlanning(blockId: string) {
     if (!workspace.workspaceId) throw new Error('No active workspace')
@@ -313,6 +356,7 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     resuming,
     controlling,
     curating,
+    recommending,
     forBlock,
     presetById,
     planningPipelineIdFor,
@@ -323,6 +367,8 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     probePreset,
     load,
     answerQuestion,
+    setQuestionStatus,
+    recommendAnswer,
     continuePlanning,
     proceedPlanning,
     control,

package/i18n/locales/de.json

@@ -3616,6 +3616,16 @@
     "next": "Weiter",
     "done": "Fertig"
   },
+  "clarification": {
+    "answerPlaceholder": "Ihre Antwort",
+    "notRelevant": "Nicht relevant",
+    "recommend": "Antwort vorschlagen",
+    "reopen": "Erneut öffnen",
+    "dismissed": "Als nicht relevant markiert",
+    "generating": "Vorschlag wird erstellt…",
+    "suggestion": "Vorgeschlagene Antwort",
+    "useSuggestion": "Diese Antwort verwenden"
+  },
   "nav": {
     "menu": "Navigationsmenü",
     "openMenu": "Menü öffnen",

package/i18n/locales/en.json

@@ -75,6 +75,16 @@
     "next": "Next",
     "done": "Done"
   },
+  "clarification": {
+    "answerPlaceholder": "Your answer",
+    "notRelevant": "Not relevant",
+    "recommend": "Recommend an answer",
+    "reopen": "Reopen",
+    "dismissed": "Marked not relevant",
+    "generating": "Drafting a suggestion…",
+    "suggestion": "Suggested answer",
+    "useSuggestion": "Use this answer"
+  },
   "nav": {
     "menu": "Navigation menu",
     "openMenu": "Open menu",

package/i18n/locales/es.json

@@ -66,6 +66,16 @@
     "next": "Siguiente",
     "done": "Listo"
   },
+  "clarification": {
+    "answerPlaceholder": "Tu respuesta",
+    "notRelevant": "No relevante",
+    "recommend": "Recomendar una respuesta",
+    "reopen": "Reabrir",
+    "dismissed": "Marcada como no relevante",
+    "generating": "Redactando una sugerencia…",
+    "suggestion": "Respuesta sugerida",
+    "useSuggestion": "Usar esta respuesta"
+  },
   "nav": {
     "menu": "Menú de navegación",
     "openMenu": "Abrir menú",

package/i18n/locales/fr.json

@@ -66,6 +66,16 @@
     "next": "Suivant",
     "done": "Terminé"
   },
+  "clarification": {
+    "answerPlaceholder": "Votre réponse",
+    "notRelevant": "Non pertinent",
+    "recommend": "Proposer une réponse",
+    "reopen": "Rouvrir",
+    "dismissed": "Marquée comme non pertinente",
+    "generating": "Rédaction d'une suggestion…",
+    "suggestion": "Réponse suggérée",
+    "useSuggestion": "Utiliser cette réponse"
+  },
   "nav": {
     "menu": "Menu de navigation",
     "openMenu": "Ouvrir le menu",

package/i18n/locales/he.json

@@ -66,6 +66,16 @@
     "next": "הבא",
     "done": "סיום"
   },
+  "clarification": {
+    "answerPlaceholder": "התשובה שלך",
+    "notRelevant": "לא רלוונטי",
+    "recommend": "המלץ על תשובה",
+    "reopen": "פתח מחדש",
+    "dismissed": "סומן כלא רלוונטי",
+    "generating": "מנסח הצעה…",
+    "suggestion": "תשובה מוצעת",
+    "useSuggestion": "השתמש בתשובה זו"
+  },
   "nav": {
     "menu": "תפריט ניווט",
     "openMenu": "פתח תפריט",

package/i18n/locales/it.json

@@ -3616,6 +3616,16 @@
     "next": "Avanti",
     "done": "Fatto"
   },
+  "clarification": {
+    "answerPlaceholder": "La tua risposta",
+    "notRelevant": "Non pertinente",
+    "recommend": "Suggerisci una risposta",
+    "reopen": "Riapri",
+    "dismissed": "Contrassegnata come non pertinente",
+    "generating": "Creazione di un suggerimento…",
+    "suggestion": "Risposta suggerita",
+    "useSuggestion": "Usa questa risposta"
+  },
   "nav": {
     "menu": "Menu di navigazione",
     "openMenu": "Apri il menu",

package/i18n/locales/ja.json

@@ -66,6 +66,16 @@
     "next": "次へ",
     "done": "完了"
   },
+  "clarification": {
+    "answerPlaceholder": "回答を入力",
+    "notRelevant": "関連なし",
+    "recommend": "回答を提案",
+    "reopen": "再開",
+    "dismissed": "関連なしとして設定",
+    "generating": "提案を作成中…",
+    "suggestion": "提案された回答",
+    "useSuggestion": "この回答を使用"
+  },
   "nav": {
     "menu": "ナビゲーションメニュー",
     "openMenu": "メニューを開く",

package/i18n/locales/pl.json

@@ -66,6 +66,16 @@
     "next": "Dalej",
     "done": "Gotowe"
   },
+  "clarification": {
+    "answerPlaceholder": "Twoja odpowiedź",
+    "notRelevant": "Nieistotne",
+    "recommend": "Zaproponuj odpowiedź",
+    "reopen": "Otwórz ponownie",
+    "dismissed": "Oznaczono jako nieistotne",
+    "generating": "Tworzenie propozycji…",
+    "suggestion": "Sugerowana odpowiedź",
+    "useSuggestion": "Użyj tej odpowiedzi"
+  },
   "nav": {
     "menu": "Menu nawigacji",
     "openMenu": "Otwórz menu",

package/i18n/locales/tr.json

@@ -66,6 +66,16 @@
     "next": "İleri",
     "done": "Bitti"
   },
+  "clarification": {
+    "answerPlaceholder": "Yanıtınız",
+    "notRelevant": "İlgili değil",
+    "recommend": "Bir yanıt öner",
+    "reopen": "Yeniden aç",
+    "dismissed": "İlgisiz olarak işaretlendi",
+    "generating": "Öneri hazırlanıyor…",
+    "suggestion": "Önerilen yanıt",
+    "useSuggestion": "Bu yanıtı kullan"
+  },
   "nav": {
     "menu": "Gezinme menüsü",
     "openMenu": "Menüyü aç",

package/i18n/locales/uk.json

@@ -66,6 +66,16 @@
     "next": "Далі",
     "done": "Готово"
   },
+  "clarification": {
+    "answerPlaceholder": "Ваша відповідь",
+    "notRelevant": "Не актуально",
+    "recommend": "Запропонувати відповідь",
+    "reopen": "Відкрити знову",
+    "dismissed": "Позначено як не актуальне",
+    "generating": "Створення пропозиції…",
+    "suggestion": "Запропонована відповідь",
+    "useSuggestion": "Використати цю відповідь"
+  },
   "nav": {
     "menu": "Меню навігації",
     "openMenu": "Відкрити меню",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.108.1",
+  "version": "0.109.2",
   "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",
@@ -34,7 +34,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.39",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.119.0"
+    "@cat-factory/contracts": "0.121.1"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",