@cat-factory/app 0.82.1 → 0.83.0

package/app/stores/board.ts

@@ -36,13 +36,55 @@ export const useBoardStore = defineStore('board', () => {
   // global i18n instance (the same handle `plugins/locale.client.ts` uses) rather than
   // `useI18n()`, which requires an active component instance.
   const nuxtApp = useNuxtApp()
-  const tr = (key: string): string => (nuxtApp.$i18n as { t: (k: string) => string }).t(key)
+  const tr = (key: string, params?: Record<string, unknown>): string =>
+    (nuxtApp.$i18n as { t: (k: string, p?: Record<string, unknown>) => string }).t(
+      key,
+      params ?? {},
+    )
   const blocks = ref<Block[]>([])
 
   // Pure derivations (hierarchy, status/progress, sizing) live in the composable.
   const queries = useBlockQueries(blocks)
   const { getBlock } = queries
 
+  /**
+   * How long a deleted block stays undoable. The backend delete is DEFERRED for this
+   * window (a real "undo", not a client illusion) — the block is hidden immediately but
+   * only actually deleted once the window elapses, so undo just cancels the pending call.
+   */
+  const UNDO_WINDOW_MS = 6000
+  /**
+   * Blocks hidden by an optimistic delete whose backend call hasn't fired yet, keyed by
+   * the deleted root's id. Their subtree stays filtered out of every incoming server
+   * snapshot (`hydrate`) and single-block live event (`upsert`) for the undo window, so a
+   * coarse refresh or a stray event can't resurrect a block the user just deleted.
+   */
+  const pendingRemovals = new Map<
+    string,
+    { snap: RemovalSnapshot; timer: ReturnType<typeof setTimeout>; wsId: string }
+  >()
+  // Flat set of every id in a pending removal (root + descendants), for O(1) checks in the
+  // hot upsert path. Kept in lockstep with `pendingRemovals`.
+  const pendingDoomed = new Set<string>()
+
+  /**
+   * Drop any pending-removal subtree from a reconciled block list and prune survivors'
+   * edges to it — the same detach the backend will perform once the deferred delete fires.
+   * Applied to every hydrate so the undo window survives a full refresh.
+   */
+  function applyPendingRemovals(list: Block[]): Block[] {
+    if (pendingDoomed.size === 0) return list
+    const survivors = list.filter((b) => !pendingDoomed.has(b.id))
+    for (const b of survivors) {
+      if (b.dependsOn.some((d) => pendingDoomed.has(d))) {
+        b.dependsOn = b.dependsOn.filter((d) => !pendingDoomed.has(d))
+      }
+      if (b.epicId != null && pendingDoomed.has(b.epicId)) b.epicId = null
+      if (b.initiativeId != null && pendingDoomed.has(b.initiativeId)) b.initiativeId = null
+    }
+    return survivors
+  }
+
   /**
    * Reconcile the cached blocks against a server snapshot, reusing the existing
    * object for any block whose content is unchanged. The server stays authoritative
@@ -67,14 +109,18 @@ export const useBoardStore = defineStore('board', () => {
   }
   function hydrate(next: Block[]) {
     const prev = new Map(blocks.value.map((b) => [b.id, b]))
-    blocks.value = next.map((n) => {
+    const reconciled = next.map((n) => {
       const existing = prev.get(n.id)
       return existing && jsonFor(existing) === jsonFor(n) ? existing : n
     })
+    // Keep blocks the user just deleted hidden while their delete is still pending.
+    blocks.value = applyPendingRemovals(reconciled)
   }
 
   /** Insert or replace a block returned by the backend. */
   function upsert(block: Block) {
+    // A live event for a block awaiting its deferred delete must not resurrect it.
+    if (pendingDoomed.has(block.id)) return
     const i = blocks.value.findIndex((b) => b.id === block.id)
     if (i >= 0) blocks.value[i] = block
     else blocks.value.push(block)
@@ -199,11 +245,16 @@ export const useBoardStore = defineStore('board', () => {
     return block
   }
 
-  /** Move a block into a new container at a new local position. */
+  /**
+   * Move a block into a new container at a new local position. Drag-reparent commits
+   * silently on a small overshoot, so a successful move (into a *different* container,
+   * not an undo of one) offers a one-click undo back to its previous home.
+   */
   async function reparentBlock(
     id: string,
     newParentId: string,
     position: { x: number; y: number },
+    opts: { undoable?: boolean } = { undoable: true },
   ) {
     const b = getBlock(id)
     const parent = getBlock(newParentId)
@@ -217,6 +268,7 @@ export const useBoardStore = defineStore('board', () => {
     // block in the wrong container (a structural lie that survives until re-hydrate).
     const prevParentId = b.parentId
     const prevPosition = b.position
+    const name = b.title
     b.parentId = newParentId
     b.position = position
     try {
@@ -226,6 +278,24 @@ export const useBoardStore = defineStore('board', () => {
           position,
         }),
       )
+      // Offer an undo back to the previous container (a drag overshoot is easy). The undo
+      // move is itself non-undoable so the toast doesn't ping-pong.
+      if (opts.undoable && prevParentId) {
+        toast.add({
+          title: tr('board.toast.moved', { name }),
+          icon: 'i-lucide-move',
+          color: 'neutral',
+          duration: UNDO_WINDOW_MS,
+          actions: [
+            {
+              label: tr('common.undo'),
+              icon: 'i-lucide-undo-2',
+              onClick: () =>
+                void reparentBlock(id, prevParentId, prevPosition, { undoable: false }),
+            },
+          ],
+        })
+      }
     } catch (e) {
       b.parentId = prevParentId
       b.position = prevPosition
@@ -291,35 +361,99 @@ export const useBoardStore = defineStore('board', () => {
   /** Re-insert a detached subtree and restore its broken edges (delete rollback). */
   function reattach(snap: RemovalSnapshot) {
     for (const b of snap.removed) if (!getBlock(b.id)) blocks.value.push(b)
+    const restored = new Set(snap.removed.map((b) => b.id))
     for (const e of snap.edges) {
       const b = getBlock(e.id)
-      if (b) {
-        b.dependsOn = e.dependsOn
-        b.epicId = e.epicId
+      if (!b) continue
+      // Re-establish only the links that pointed at a now-restored block, merged with
+      // whatever the survivor gained meanwhile — so a delayed undo (the delete is deferred by
+      // a window during which a live event may add edges) doesn't clobber a newer dependency /
+      // epic / initiative link with the stale detach-time snapshot.
+      const readd = e.dependsOn.filter((d) => restored.has(d) && !b.dependsOn.includes(d))
+      if (readd.length) b.dependsOn = [...b.dependsOn, ...readd]
+      if (b.epicId == null && e.epicId != null && restored.has(e.epicId)) b.epicId = e.epicId
+      if (b.initiativeId == null && e.initiativeId != null && restored.has(e.initiativeId)) {
         b.initiativeId = e.initiativeId
       }
     }
   }
 
   /**
-   * Delete a block. The subtree is hidden IMMEDIATELY (optimistic) so the board
-   * feels instant; if the backend rejects the delete we put it back and surface a
-   * toast rather than silently leaving a ghost.
+   * Delete a block. The subtree is hidden IMMEDIATELY (optimistic) so the board feels
+   * instant, and the real backend delete is DEFERRED by {@link UNDO_WINDOW_MS} so the
+   * accompanying "Deleted — Undo" toast can cancel it in place (a genuine undo, since
+   * nothing was destroyed server-side yet). The subtree stays filtered out of any
+   * hydrate/upsert in the meantime (see {@link applyPendingRemovals}). If the deferred
+   * call ultimately fails we put the subtree back and surface an error toast.
    */
-  async function removeBlock(id: string) {
+  function removeBlock(
+    id: string,
+    opts: { onCommit?: (wsId: string) => void | Promise<void> } = {},
+  ) {
+    const block = getBlock(id)
     const snap = detach(id)
-    if (!snap) return
-    try {
-      await api.removeBlock(useWorkspaceStore().requireId(), id)
-    } catch (e) {
-      reattach(snap)
-      toast.add({
-        title: tr('board.toast.deleteFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
+    if (!block || !snap) return
+    // Capture the workspace now: the deferred delete must target the workspace the block
+    // was deleted from even if the user has since switched.
+    const wsId = useWorkspaceStore().requireId()
+    for (const b of snap.removed) pendingDoomed.add(b.id)
+
+    const finalize = async () => {
+      const pending = pendingRemovals.get(id)
+      if (!pending) return
+      pendingRemovals.delete(id)
+      try {
+        // Any irreversible side effect the delete implies (e.g. cancelling the block's run)
+        // is deferred to here so it fires only once the delete truly commits — undo within
+        // the window then leaves the run untouched instead of restoring an already-cancelled one.
+        await opts.onCommit?.(pending.wsId)
+        await api.removeBlock(pending.wsId, id)
+        // Stop filtering the subtree only after the server has actually dropped it, so a
+        // snapshot that raced the in-flight delete can't briefly resurrect it.
+        for (const b of pending.snap.removed) pendingDoomed.delete(b.id)
+      } catch (e) {
+        for (const b of pending.snap.removed) pendingDoomed.delete(b.id)
+        // Only restore into the board the block was deleted from; a mid-window workspace
+        // switch must not inject the old subtree onto the workspace now on screen (it
+        // re-hydrates from the server there on the next refresh anyway).
+        if (useWorkspaceStore().workspaceId === pending.wsId) reattach(pending.snap)
+        toast.add({
+          title: tr('board.toast.deleteFailed'),
+          description: e instanceof Error ? e.message : String(e),
+          icon: 'i-lucide-triangle-alert',
+          color: 'error',
+        })
+      }
     }
+    const timer = setTimeout(() => void finalize(), UNDO_WINDOW_MS)
+    pendingRemovals.set(id, { snap, timer, wsId })
+
+    toast.add({
+      title: tr('board.toast.deleted', { name: block.title }),
+      icon: 'i-lucide-trash-2',
+      color: 'neutral',
+      duration: UNDO_WINDOW_MS,
+      actions: [
+        {
+          label: tr('common.undo'),
+          icon: 'i-lucide-undo-2',
+          onClick: () => undoRemove(id),
+        },
+      ],
+    })
+  }
+
+  /** Cancel a still-pending delete and restore the hidden subtree. */
+  function undoRemove(id: string) {
+    const pending = pendingRemovals.get(id)
+    if (!pending) return
+    clearTimeout(pending.timer)
+    pendingRemovals.delete(id)
+    for (const b of pending.snap.removed) pendingDoomed.delete(b.id)
+    // Don't resurrect the subtree into a different workspace if the user navigated away
+    // mid-window; the delete was already cancelled, which is the safe outcome there.
+    if (useWorkspaceStore().workspaceId !== pending.wsId) return
+    reattach(pending.snap)
   }
 
   /**
@@ -357,7 +491,7 @@ export const useBoardStore = defineStore('board', () => {
       // spot the server never stored (a lie that survives until the next re-hydrate).
       b.position = prevPosition
       toast.add({
-        title: 'Could not move',
+        title: tr('board.toast.moveFailed'),
         description: e instanceof Error ? e.message : String(e),
         icon: 'i-lucide-triangle-alert',
         color: 'error',

package/app/stores/execution.ts

@@ -304,10 +304,14 @@ export const useExecutionStore = defineStore('execution', () => {
     }
   }
 
-  /** Cancel the execution running against a block and reset it to planned. */
-  async function cancel(blockId: string) {
+  /**
+   * Cancel the execution running against a block and reset it to planned. `workspaceId`
+   * defaults to the current workspace but can be pinned by callers that cancel a run for a
+   * board the user may have since navigated away from (e.g. a deferred delete's commit).
+   */
+  async function cancel(blockId: string, workspaceId?: string) {
     const ws = useWorkspaceStore()
-    await api.cancelExecution(ws.requireId(), blockId)
+    await api.cancelExecution(workspaceId ?? ws.requireId(), blockId)
     instances.value = instances.value.filter((e) => e.blockId !== blockId)
     await ws.refresh()
   }

package/app/stores/initiative.ts

@@ -90,9 +90,66 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     }
   }
 
+  /** True while a planning-window action (continue/proceed) is resuming the run. */
+  const resuming = ref(false)
+
+  /** Record the human's answer to one pending interview question (no run resume). */
+  async function answerQuestion(blockId: string, questionId: string, answer: string) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    const updated = await api.answerInitiativeQuestion(
+      workspace.workspaceId,
+      blockId,
+      questionId,
+      answer,
+    )
+    upsert(updated)
+    return updated
+  }
+
+  /** 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')
+    resuming.value = true
+    try {
+      const updated = await api.continueInitiativePlanning(workspace.workspaceId, blockId)
+      upsert(updated)
+      return updated
+    } finally {
+      resuming.value = false
+    }
+  }
+
+  /** Skip remaining questions: the interviewer converges and the run advances. */
+  async function proceedPlanning(blockId: string) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    resuming.value = true
+    try {
+      const updated = await api.proceedInitiativePlanning(workspace.workspaceId, blockId)
+      upsert(updated)
+      return updated
+    } finally {
+      resuming.value = false
+    }
+  }
+
   function reset() {
     byBlock.value = {}
   }
 
-  return { available, byBlock, all, creating, forBlock, hydrate, upsert, create, load, reset }
+  return {
+    available,
+    byBlock,
+    all,
+    creating,
+    resuming,
+    forBlock,
+    hydrate,
+    upsert,
+    create,
+    load,
+    answerQuestion,
+    continuePlanning,
+    proceedPlanning,
+    reset,
+  }
 })

package/app/stores/ui.ts

@@ -728,6 +728,11 @@ export const useUiStore = defineStore('ui', () => {
   function openInitiativeTracker(blockId: string) {
     resultView.value = { view: 'initiative-tracker', blockId, instanceId: null, stepIndex: null }
   }
+  // Open the interactive-planning Q&A window for an initiative block (inspector / card,
+  // when the interviewer has parked the planning run with pending questions).
+  function openInitiativePlanning(blockId: string) {
+    resultView.value = { view: 'initiative-planning', blockId, instanceId: null, stepIndex: null }
+  }
   // Open the Follow-up companion window for a run's Coder step (the blinking chip + the
   // `followup_pending` notification). Resolves the Coder step index from the run when not
   // given, so callers that only know the run can still open it.
@@ -939,6 +944,7 @@ export const useUiStore = defineStore('ui', () => {
     openBrainstorm,
     openServiceSpec,
     openInitiativeTracker,
+    openInitiativePlanning,
     openFollowUps,
     closeRequirementReview,
     openStepDetail,

package/app/utils/catalog.ts

@@ -347,6 +347,25 @@ export const SYSTEM_AGENT_META: Record<string, AgentArchetype> = {
   // The Initiative Planning pipeline's two steps. Only runnable on an initiative
   // block (pl_initiative — enforced by the engine), so they are display-metadata
   // system kinds, never palette archetypes.
+  'initiative-interviewer': {
+    kind: 'initiative-interviewer',
+    label: 'Initiative Interviewer',
+    icon: 'i-lucide-messages-square',
+    color: '#818cf8',
+    description:
+      'Interviews you on the goals, scope and constraints of the initiative, then synthesizes the agreed brief the analyst and planner build on.',
+    // Opens the dedicated planning Q&A window (answer / continue / proceed) while parked.
+    resultView: 'initiative-planning',
+  },
+  'initiative-analyst': {
+    kind: 'initiative-analyst',
+    label: 'Initiative Analyst',
+    icon: 'i-lucide-microscope',
+    color: '#818cf8',
+    description:
+      'Explores the codebase and writes an analysis (architecture, touch points, risks) that grounds the plan. Makes no changes.',
+    resultView: 'initiative-tracker',
+  },
   'initiative-planner': {
     kind: 'initiative-planner',
     label: 'Initiative Planner',

package/i18n/locales/en.json

@@ -59,7 +59,8 @@
     },
     "@clear": {
       "description": "Verb meaning empty / reset a stored value (a config, a saved connection), NOT the adjective 'transparent / obvious'. Used as a destructive-action button label."
-    }
+    },
+    "undo": "Undo"
   },
   "nav": {
     "menu": "Navigation menu",
@@ -95,7 +96,9 @@
       "moveFailed": "Could not move",
       "deleteFailed": "Could not delete",
       "linkFailed": "Could not link tasks",
-      "recurringDeleteFailed": "Could not delete recurring pipeline"
+      "recurringDeleteFailed": "Could not delete recurring pipeline",
+      "deleted": "Deleted \"{name}\"",
+      "moved": "Moved \"{name}\""
     },
     "repoTypes": {
       "service": "Service",
@@ -985,7 +988,8 @@
         "recurring": {
           "title": "Delete this recurring pipeline?",
           "body": "\"{name}\", its schedule and its run history will be removed. This can't be undone."
-        }
+        },
+        "containerBodyWithCount": "\"{name}\" and the {count} item inside it will be removed. This can't be undone. | \"{name}\" and the {count} items inside it will be removed. This can't be undone."
       },
       "titlePlaceholder": "Title…",
       "reworkedRequirements": "Reworked requirements",
@@ -4135,7 +4139,19 @@
     },
     "inspector": {
       "runPlanning": "Run planning",
+      "answerPlanning": "Answer planning questions",
       "hint": "The planning pipeline explores the codebase, drafts the multi-phase plan for approval, then commits the tracker document to the repository."
+    },
+    "planning": {
+      "title": "Plan the initiative",
+      "subtitle": "Answer the planner's questions so it can scope the initiative",
+      "intro": "The planner is scoping this initiative. Answer its questions to shape the goal and constraints, then continue — or proceed to plan with what it has.",
+      "empty": "No initiative found for this block.",
+      "converged": "No questions are pending. The planner has what it needs and is drafting the plan.",
+      "answerPlaceholder": "Your answer",
+      "hint": "Continue lets the planner ask follow-ups; Proceed plans with the answers so far.",
+      "proceed": "Proceed to plan",
+      "continue": "Continue"
     }
   }
 }

package/i18n/locales/es.json

@@ -50,7 +50,8 @@
       "revoked": "{name} revocado",
       "cleared": "{name} borrado",
       "destroyed": "{name} destruido"
-    }
+    },
+    "undo": "Deshacer"
   },
   "nav": {
     "menu": "Menú de navegación",
@@ -80,7 +81,9 @@
       "moveFailed": "No se pudo mover",
       "deleteFailed": "No se pudo eliminar",
       "linkFailed": "No se pudieron vincular las tareas",
-      "recurringDeleteFailed": "No se pudo eliminar el pipeline recurrente"
+      "recurringDeleteFailed": "No se pudo eliminar el pipeline recurrente",
+      "deleted": "\"{name}\" eliminado",
+      "moved": "\"{name}\" movido"
     },
     "repoTypes": {
       "service": "Servicio",
@@ -960,7 +963,8 @@
         "recurring": {
           "title": "¿Eliminar este pipeline recurrente?",
           "body": "Se eliminarán \"{name}\", su programación y su historial de ejecución. Esta acción no se puede deshacer."
-        }
+        },
+        "containerBodyWithCount": "Se eliminará \"{name}\" y el {count} elemento que contiene. Esta acción no se puede deshacer. | Se eliminará \"{name}\" y los {count} elementos que contiene. Esta acción no se puede deshacer."
       }
     }
   },
@@ -4016,7 +4020,19 @@
     },
     "inspector": {
       "runPlanning": "Ejecutar planificacion",
+      "answerPlanning": "Responder preguntas de planificacion",
       "hint": "El pipeline de planificacion explora el codigo, redacta el plan multifase para su aprobacion y luego confirma el documento de seguimiento en el repositorio."
+    },
+    "planning": {
+      "title": "Planificar la iniciativa",
+      "subtitle": "Responde las preguntas del planificador para acotar la iniciativa",
+      "intro": "El planificador esta acotando esta iniciativa. Responde sus preguntas para definir el objetivo y las restricciones, luego continua, o procede a planificar con lo que tiene.",
+      "empty": "No se encontro ninguna iniciativa para este bloque.",
+      "converged": "No hay preguntas pendientes. El planificador tiene lo que necesita y esta redactando el plan.",
+      "answerPlaceholder": "Tu respuesta",
+      "hint": "Continuar permite al planificador hacer mas preguntas; Proceder planifica con las respuestas actuales.",
+      "proceed": "Proceder a planificar",
+      "continue": "Continuar"
     }
   }
 }

package/i18n/locales/fr.json

@@ -50,7 +50,8 @@
       "revoked": "{name} révoqué",
       "cleared": "{name} effacé",
       "destroyed": "{name} détruit"
-    }
+    },
+    "undo": "Annuler"
   },
   "nav": {
     "menu": "Menu de navigation",
@@ -80,7 +81,9 @@
       "moveFailed": "Impossible de déplacer",
       "deleteFailed": "Impossible de supprimer",
       "linkFailed": "Impossible de lier les tâches",
-      "recurringDeleteFailed": "Impossible de supprimer le pipeline récurrent"
+      "recurringDeleteFailed": "Impossible de supprimer le pipeline récurrent",
+      "deleted": "\"{name}\" supprimé",
+      "moved": "\"{name}\" déplacé"
     },
     "repoTypes": {
       "service": "Service",
@@ -960,7 +963,8 @@
         "recurring": {
           "title": "Supprimer ce pipeline récurrent ?",
           "body": "\"{name}\", sa planification et son historique d'exécution seront supprimés. Cette action est irréversible."
-        }
+        },
+        "containerBodyWithCount": "\"{name}\" et le {count} élément qu'il contient seront supprimés. Cette action est irréversible. | \"{name}\" et les {count} éléments qu'il contient seront supprimés. Cette action est irréversible."
       }
     }
   },
@@ -4016,7 +4020,19 @@
     },
     "inspector": {
       "runPlanning": "Lancer la planification",
+      "answerPlanning": "Repondre aux questions de planification",
       "hint": "Le pipeline de planification explore le code, redige le plan multiphase pour approbation, puis valide le document de suivi dans le depot."
+    },
+    "planning": {
+      "title": "Planifier l'initiative",
+      "subtitle": "Repondez aux questions du planificateur pour cadrer l'initiative",
+      "intro": "Le planificateur cadre cette initiative. Repondez a ses questions pour definir l'objectif et les contraintes, puis continuez, ou procedez a la planification avec ce qu'il a.",
+      "empty": "Aucune initiative trouvee pour ce bloc.",
+      "converged": "Aucune question en attente. Le planificateur dispose de ce qu'il faut et redige le plan.",
+      "answerPlaceholder": "Votre reponse",
+      "hint": "Continuer permet au planificateur de poser des questions complementaires ; Proceder planifie avec les reponses actuelles.",
+      "proceed": "Proceder a la planification",
+      "continue": "Continuer"
     }
   }
 }

package/i18n/locales/he.json

@@ -50,7 +50,8 @@
       "revoked": "{name} בוטל",
       "cleared": "{name} נוקה",
       "destroyed": "{name} הושמד"
-    }
+    },
+    "undo": "בטל"
   },
   "nav": {
     "menu": "תפריט ניווט",
@@ -80,7 +81,9 @@
       "moveFailed": "לא ניתן היה להעביר",
       "deleteFailed": "לא ניתן היה למחוק",
       "linkFailed": "לא ניתן היה לקשר משימות",
-      "recurringDeleteFailed": "לא ניתן היה למחוק את הצינור החוזר"
+      "recurringDeleteFailed": "לא ניתן היה למחוק את הצינור החוזר",
+      "deleted": "\"{name}\" נמחק",
+      "moved": "\"{name}\" הועבר"
     },
     "repoTypes": {
       "service": "שירות",
@@ -960,7 +963,8 @@
         "recurring": {
           "title": "למחוק את ה־pipeline החוזר הזה?",
           "body": "\"{name}\", התזמון שלו והיסטוריית ההרצות יימחקו. לא ניתן לבטל פעולה זו."
-        }
+        },
+        "containerBodyWithCount": "\"{name}\" ו-{count} פריט שבתוכו יימחקו. לא ניתן לבטל פעולה זו. | \"{name}\" ו-{count} פריטים שבתוכו יימחקו. לא ניתן לבטל פעולה זו."
       }
     }
   },
@@ -4027,7 +4031,19 @@
     },
     "inspector": {
       "runPlanning": "הרצת תכנון",
+      "answerPlanning": "מענה על שאלות התכנון",
       "hint": "צינור התכנון חוקר את הקוד, מנסח את התוכנית הרב-שלבית לאישור, ואז שומר את מסמך המעקב במאגר."
+    },
+    "planning": {
+      "title": "תכנון היוזמה",
+      "subtitle": "ענה על שאלות המתכנן כדי למקד את היוזמה",
+      "intro": "המתכנן ממקד את היוזמה. ענה על שאלותיו כדי לעצב את המטרה והאילוצים, ואז המשך — או עבור לתכנון עם מה שיש לו.",
+      "empty": "לא נמצאה יוזמה עבור בלוק זה.",
+      "converged": "אין שאלות ממתינות. למתכנן יש את מה שנדרש והוא מנסח את התוכנית.",
+      "answerPlaceholder": "התשובה שלך",
+      "hint": "המשך מאפשר למתכנן לשאול שאלות המשך; עבור לתכנון מתכנן עם התשובות עד כה.",
+      "proceed": "עבור לתכנון",
+      "continue": "המשך"
     }
   }
 }

package/i18n/locales/ja.json

@@ -50,7 +50,8 @@
       "revoked": "{name} を取り消しました",
       "cleared": "{name} をクリアしました",
       "destroyed": "{name} を破棄しました"
-    }
+    },
+    "undo": "元に戻す"
   },
   "nav": {
     "menu": "ナビゲーションメニュー",
@@ -80,7 +81,9 @@
       "moveFailed": "移動できませんでした",
       "deleteFailed": "削除できませんでした",
       "linkFailed": "タスクをリンクできませんでした",
-      "recurringDeleteFailed": "定期パイプラインを削除できませんでした"
+      "recurringDeleteFailed": "定期パイプラインを削除できませんでした",
+      "deleted": "\"{name}\" を削除しました",
+      "moved": "\"{name}\" を移動しました"
     },
     "repoTypes": {
       "service": "サービス",
@@ -960,7 +963,8 @@
         "recurring": {
           "title": "この定期パイプラインを削除しますか？",
           "body": "「{name}」、そのスケジュール、実行履歴が削除されます。この操作は取り消せません。"
-        }
+        },
+        "containerBodyWithCount": "「{name}」とその中の {count} 件の項目が削除されます。この操作は取り消せません。 | 「{name}」とその中の {count} 件の項目が削除されます。この操作は取り消せません。"
       }
     }
   },
@@ -4029,7 +4033,19 @@
     },
     "inspector": {
       "runPlanning": "計画を実行",
+      "answerPlanning": "計画の質問に回答",
       "hint": "計画パイプラインはコードベースを調査し、承認用の複数フェーズ計画を起草し、その後トラッカー文書をリポジトリにコミットします。"
+    },
+    "planning": {
+      "title": "イニシアチブを計画",
+      "subtitle": "プランナーの質問に答えてイニシアチブの範囲を定めます",
+      "intro": "プランナーがこのイニシアチブの範囲を検討しています。質問に答えて目標と制約を形にし、続行するか、現状のまま計画に進んでください。",
+      "empty": "このブロックのイニシアチブが見つかりません。",
+      "converged": "保留中の質問はありません。プランナーは必要な情報を得て計画を作成しています。",
+      "answerPlaceholder": "回答",
+      "hint": "「続行」でプランナーが追加の質問をします。「計画に進む」でこれまでの回答をもとに計画します。",
+      "proceed": "計画に進む",
+      "continue": "続行"
     }
   }
 }