@cat-factory/app 0.81.0 → 0.82.0

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

@@ -0,0 +1,78 @@
+<script setup lang="ts">
+// Inspector body for an `initiative`-level block: the entity's status + goal, the
+// "Run planning" control (pinned to the Initiative Planning pipeline — the engine
+// refuses any other on this block), and the tracker window opener. Read-only in
+// this slice; plan/policy editing lands with the execution loop.
+import type { Block, InitiativeStatus } from '~/types/domain'
+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 ONLY pipeline runnable on an initiative block (see the engine's runnable guard).
+const planningPipeline = computed(() => pipelines.pipelines.find((p) => p.id === 'pl_initiative'))
+const running = computed(() => !!props.block.executionId)
+
+function runPlanning() {
+  if (planningPipeline.value) void execution.start(props.block.id, planningPipeline.value)
+}
+function openTracker() {
+  ui.openInitiativeTracker(props.block.id)
+}
+
+const progress = computed(() => initiativeProgress(initiative.value?.items))
+</script>
+
+<template>
+  <div class="space-y-3" data-testid="initiative-inspector">
+    <div class="flex items-center gap-2">
+      <UBadge color="primary" variant="subtle" size="sm">
+        {{ t(INITIATIVE_STATUS_LABEL_KEYS[status]) }}
+      </UBadge>
+      <span v-if="progress" class="text-[11px] text-slate-400">
+        {{ t('initiative.card.progress', { done: progress.settled, total: progress.total }) }}
+      </span>
+    </div>
+
+    <p v-if="initiative?.goal" class="whitespace-pre-wrap text-[12px] text-slate-300">
+      {{ initiative.goal }}
+    </p>
+
+    <div class="flex flex-wrap items-center gap-2">
+      <UButton
+        data-testid="initiative-run-planning"
+        color="primary"
+        variant="soft"
+        size="sm"
+        icon="i-lucide-play"
+        :disabled="!planningPipeline || running"
+        @click="runPlanning"
+      >
+        {{ t('initiative.inspector.runPlanning') }}
+      </UButton>
+      <UButton
+        data-testid="initiative-inspector-tracker"
+        color="neutral"
+        variant="soft"
+        size="sm"
+        icon="i-lucide-list-checks"
+        @click="openTracker"
+      >
+        {{ t('initiative.card.openTracker') }}
+      </UButton>
+    </div>
+
+    <p class="text-[11px] text-slate-500">
+      {{ t('initiative.inspector.hint') }}
+    </p>
+  </div>
+</template>

package/app/composables/api/initiative.ts

@@ -0,0 +1,28 @@
+import {
+  createInitiativeContract,
+  getInitiativeByBlockContract,
+  getInitiativeContract,
+  listInitiativesContract,
+} from '@cat-factory/contracts'
+import type { ApiContext } from './context'
+
+/** Initiatives: the long-running multi-task work containers (create + tracker reads). */
+export function initiativeApi({ send, ws }: ApiContext) {
+  return {
+    // Create the initiative-level board block AND its empty entity in one call.
+    createInitiative: (
+      workspaceId: string,
+      body: { frameId: string; title: string; description?: string },
+    ) => send(createInitiativeContract, { pathPrefix: ws(workspaceId), body }),
+
+    listInitiatives: (workspaceId: string) =>
+      send(listInitiativesContract, { pathPrefix: ws(workspaceId) }),
+
+    getInitiative: (workspaceId: string, initiativeId: string) =>
+      send(getInitiativeContract, { pathPrefix: ws(workspaceId), pathParams: { initiativeId } }),
+
+    // The tracker window's load path: the initiative anchored to a board block.
+    getInitiativeByBlock: (workspaceId: string, blockId: string) =>
+      send(getInitiativeByBlockContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
+  }
+}

package/app/composables/useApi.ts

@@ -13,6 +13,7 @@ import { githubApi } from './api/github'
 import { humanReviewApi } from './api/humanReview'
 import { humanTestApi } from './api/humanTest'
 import { infraHandlersApi } from './api/infraHandlers'
+import { initiativeApi } from './api/initiative'
 import { visualConfirmApi } from './api/visualConfirm'
 import { kaizenApi } from './api/kaizen'
 import { localSettingsApi } from './api/localSettings'
@@ -112,6 +113,7 @@ export function useApi() {
     ...presetsApi(ctx),
     ...providerConnectionsApi(ctx),
     ...infraHandlersApi(ctx),
+    ...initiativeApi(ctx),
     ...provisioningLogsApi(ctx),
     ...releaseHealthApi(ctx),
     ...packageRegistriesApi(ctx),

package/app/composables/useBlockQueries.ts

@@ -59,6 +59,11 @@ export function useBlockQueries(blocks: Ref<Block[]>) {
     return childrenOf(serviceId).filter((b) => b.level === 'module')
   }
 
+  /** Initiative containers inside a service (frame children, like modules). */
+  function initiativesOf(serviceId: string) {
+    return childrenOf(serviceId).filter((b) => b.level === 'initiative')
+  }
+
   /** Tasks anywhere under a container — directly, or nested inside its modules. */
   function allTasksUnder(containerId: string): Block[] {
     const direct = tasksOf(containerId)
@@ -124,9 +129,17 @@ export function useBlockQueries(blocks: Ref<Block[]>) {
    */
   function frameStatus(frameId: string): BlockStatus {
     const tasks = allTasksUnder(frameId)
-    if (tasks.length === 0) return 'planned'
-    if (tasks.some((t) => t.status === 'blocked')) return 'blocked'
-    if (tasks.some((t) => t.status === 'in_progress' || t.status === 'pr_ready'))
+    // Initiative containers are frame children too: a frame holding only an initiative
+    // is NOT empty, and an active (planning/executing → block `in_progress`) or blocked
+    // initiative drives the frame's activity dot just like a task does.
+    const inits = initiativesOf(frameId)
+    if (tasks.length === 0 && inits.length === 0) return 'planned'
+    if (tasks.some((t) => t.status === 'blocked') || inits.some((i) => i.status === 'blocked'))
+      return 'blocked'
+    if (
+      tasks.some((t) => t.status === 'in_progress' || t.status === 'pr_ready') ||
+      inits.some((i) => i.status === 'in_progress')
+    )
       return 'in_progress'
     return 'ready'
   }
@@ -153,6 +166,11 @@ export function useBlockQueries(blocks: Ref<Block[]>) {
       w = Math.max(w, m.position.x + s.w + 12)
       inner = Math.max(inner, m.position.y + s.h + 12)
     }
+    // Initiative cards render inside the frame's drop zone like tasks (230×~170).
+    for (const i of initiativesOf(id)) {
+      w = Math.max(w, i.position.x + 230 + 12)
+      inner = Math.max(inner, i.position.y + 170 + 12)
+    }
     return { w, h: inner + headerH }
   }
 
@@ -180,6 +198,7 @@ export function useBlockQueries(blocks: Ref<Block[]>) {
     childrenOf,
     tasksOf,
     modulesOf,
+    initiativesOf,
     allTasksUnder,
     serviceOf,
     unmetDeps,

package/app/composables/useWorkspaceStream.ts

@@ -25,6 +25,7 @@ export function useWorkspaceStream() {
   const clarity = useClarityStore()
   const brainstorm = useBrainstormStore()
   const kaizen = useKaizenStore()
+  const initiatives = useInitiativesStore()
   const api = useApi()
   const apiBase = useRuntimeConfig().public.apiBase
 
@@ -103,6 +104,10 @@ export function useWorkspaceStream() {
       // run cache (so an open run window shows scheduled→running→complete live) and the
       // Kaizen screen history. Never surfaced on the board.
       kaizen.upsert(event.grading)
+    } else if (event.type === 'initiative') {
+      // An initiative changed (created, plan ingested, an item settled) — patch the cache
+      // so an open tracker window / the board card reflects the transition live.
+      initiatives.upsert(event.initiative)
     }
   }
 

package/app/pages/index.vue

@@ -332,6 +332,7 @@ watch(
       <AgentStepDetail />
       <StepResultViewHost />
       <AddTaskModal />
+      <CreateInitiativeModal />
       <CommandBar />
       <PersonalCredentialModal />
       <ConfirmDialog />

package/app/stores/board.ts

@@ -22,8 +22,11 @@ import { useBlockQueries } from '~/composables/useBlockQueries'
 interface RemovalSnapshot {
   /** The removed block + all its descendants, in their original order. */
   removed: Block[]
-  /** Survivors whose `dependsOn`/`epicId` lost an edge to a removed block (originals to restore). */
-  edges: { id: string; dependsOn: string[]; epicId: string | null }[]
+  /**
+   * Survivors whose `dependsOn`/`epicId`/`initiativeId` lost an edge to a removed block
+   * (originals to restore on rollback).
+   */
+  edges: { id: string; dependsOn: string[]; epicId: string | null; initiativeId: string | null }[]
 }
 
 export const useBoardStore = defineStore('board', () => {
@@ -255,15 +258,23 @@ export const useBoardStore = defineStore('board', () => {
       }
     }
     const removed = blocks.value.filter((b) => doomed.has(b.id))
-    // Survivors that pointed at a doomed block (dependency edge or epic membership) lose
-    // that link — snapshot the originals so a failed delete restores them faithfully.
+    // Survivors that pointed at a doomed block (dependency edge, epic membership, or initiative
+    // membership) lose that link — snapshot the originals so a failed delete restores them
+    // faithfully. Mirrors the backend `pruneDanglingEdges` detach.
     const edges = blocks.value
       .filter(
         (b) =>
           !doomed.has(b.id) &&
-          (b.dependsOn.some((d) => doomed.has(d)) || (b.epicId != null && doomed.has(b.epicId))),
+          (b.dependsOn.some((d) => doomed.has(d)) ||
+            (b.epicId != null && doomed.has(b.epicId)) ||
+            (b.initiativeId != null && doomed.has(b.initiativeId))),
       )
-      .map((b) => ({ id: b.id, dependsOn: [...b.dependsOn], epicId: b.epicId ?? null }))
+      .map((b) => ({
+        id: b.id,
+        dependsOn: [...b.dependsOn],
+        epicId: b.epicId ?? null,
+        initiativeId: b.initiativeId ?? null,
+      }))
     blocks.value = blocks.value.filter((b) => !doomed.has(b.id))
     for (const b of blocks.value) {
       if (b.dependsOn.some((d) => doomed.has(d))) {
@@ -271,6 +282,8 @@ export const useBoardStore = defineStore('board', () => {
       }
       // A member of a deleted epic loses its membership (the task itself survives).
       if (b.epicId != null && doomed.has(b.epicId)) b.epicId = null
+      // Likewise a task spawned by a deleted initiative loses its (non-structural) membership.
+      if (b.initiativeId != null && doomed.has(b.initiativeId)) b.initiativeId = null
     }
     return { removed, edges }
   }
@@ -283,6 +296,7 @@ export const useBoardStore = defineStore('board', () => {
       if (b) {
         b.dependsOn = e.dependsOn
         b.epicId = e.epicId
+        b.initiativeId = e.initiativeId
       }
     }
   }

package/app/stores/initiative.ts

@@ -0,0 +1,98 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { Initiative } from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { useBoardStore } from '~/stores/board'
+
+/**
+ * Initiative state — the long-running multi-task work containers, keyed by their
+ * anchor BLOCK id (the id everything on the board navigates by). Hydrated from the
+ * workspace snapshot (`snapshot.initiatives`) and patched live from `initiative`
+ * stream events; `create` calls the API and applies the authoritative entity +
+ * block the server returns. `available` mirrors the backend's opt-in module (a 503
+ * hides the UI). Per-workspace; nothing is persisted client-side.
+ *
+ * NOTE: distinct from `useTrackerStore` (the workspace's ISSUE-tracker selection) —
+ * "tracker" in initiative-land means the initiative's plan/tracker document.
+ */
+export const useInitiativesStore = defineStore('initiatives', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+
+  /** null = unknown (not probed), true/false = feature on/off. */
+  const available = ref<boolean | null>(null)
+  /** The entities keyed by their anchor block id. */
+  const byBlock = ref<Record<string, Initiative>>({})
+  /** True while a create call is in flight (the modal's submit spinner). */
+  const creating = ref(false)
+
+  const all = computed(() => Object.values(byBlock.value))
+
+  function forBlock(blockId: string): Initiative | null {
+    return byBlock.value[blockId] ?? null
+  }
+
+  /**
+   * Rebuild the cache from a snapshot (the hydrate fan-out). The snapshot is authoritative
+   * for EXISTENCE (entities it omits are dropped — they were deleted), but NOT for freshness:
+   * a stale snapshot captured before a live `initiative` event must not regress a newer entity
+   * already patched into the store. So for a blockId present in both, keep whichever `rev` is
+   * higher — the same live-event-vs-resync race guard `upsert` applies, mirroring the fix the
+   * repo's flake note describes for `agentRuns.hydrate`.
+   */
+  function hydrate(next: Initiative[] | undefined) {
+    if (next === undefined) return
+    available.value = true
+    const map: Record<string, Initiative> = {}
+    for (const initiative of next) {
+      const existing = byBlock.value[initiative.blockId]
+      map[initiative.blockId] = existing && existing.rev > initiative.rev ? existing : initiative
+    }
+    byBlock.value = map
+  }
+
+  /** Patch from a live `initiative` stream event or a call response (newest rev wins). */
+  function upsert(initiative: Initiative) {
+    const existing = byBlock.value[initiative.blockId]
+    if (existing && existing.rev > initiative.rev) return
+    byBlock.value = { ...byBlock.value, [initiative.blockId]: initiative }
+  }
+
+  /** Create an initiative under a service frame (block + entity in one call). */
+  async function create(frameId: string, input: { title: string; description?: string }) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    creating.value = true
+    try {
+      const created = await api.createInitiative(workspace.workspaceId, {
+        frameId,
+        title: input.title,
+        ...(input.description ? { description: input.description } : {}),
+      })
+      useBoardStore().upsert(created.block)
+      upsert(created.initiative)
+      return created
+    } finally {
+      creating.value = false
+    }
+  }
+
+  /** Re-fetch one block's initiative (the tracker window's load path). */
+  async function load(blockId: string) {
+    if (!workspace.workspaceId) return
+    try {
+      const initiative = await api.getInitiativeByBlock(workspace.workspaceId, blockId)
+      available.value = true
+      if (initiative) upsert(initiative)
+    } catch (error) {
+      const status = (error as { status?: number } | null)?.status
+      if (status === 503) available.value = false
+      else throw error
+    }
+  }
+
+  function reset() {
+    byBlock.value = {}
+  }
+
+  return { available, byBlock, all, creating, forBlock, hydrate, upsert, create, load, reset }
+})

package/app/stores/ui.ts

@@ -86,6 +86,10 @@ export const useUiStore = defineStore('ui', () => {
   // the frame opens it, scoped to that frame).
   const addRecurringFrameId = ref<string | null>(null)
 
+  // Create-initiative modal: the service frame a new initiative is being created
+  // under, or null when closed (mirrors the add-task flow).
+  const createInitiativeFrameId = ref<string | null>(null)
+
   // Repo-bootstrap modal (manage reference architectures + launch a bootstrap).
   const bootstrapOpen = ref(false)
 
@@ -424,6 +428,12 @@ export const useUiStore = defineStore('ui', () => {
   function closeAddRecurring() {
     addRecurringFrameId.value = null
   }
+  function openCreateInitiative(frameId: string) {
+    createInitiativeFrameId.value = frameId
+  }
+  function closeCreateInitiative() {
+    createInitiativeFrameId.value = null
+  }
   function openBootstrap() {
     bootstrapOpen.value = true
   }
@@ -714,6 +724,10 @@ export const useUiStore = defineStore('ui', () => {
   function openServiceSpec(blockId: string) {
     resultView.value = { view: 'service-spec', blockId, instanceId: null, stepIndex: null }
   }
+  // Open the initiative tracker window for an initiative block (board card / inspector).
+  function openInitiativeTracker(blockId: string) {
+    resultView.value = { view: 'initiative-tracker', 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.
@@ -783,6 +797,7 @@ export const useUiStore = defineStore('ui', () => {
     addTaskContainerId,
     addTaskPrefill,
     addRecurringFrameId,
+    createInitiativeFrameId,
     bootstrapOpen,
     addServiceOpen,
     githubOpen,
@@ -856,6 +871,8 @@ export const useUiStore = defineStore('ui', () => {
     closeAddTask,
     openAddRecurring,
     closeAddRecurring,
+    openCreateInitiative,
+    closeCreateInitiative,
     openBootstrap,
     closeBootstrap,
     openAddService,
@@ -921,6 +938,7 @@ export const useUiStore = defineStore('ui', () => {
     openClarityReview,
     openBrainstorm,
     openServiceSpec,
+    openInitiativeTracker,
     openFollowUps,
     closeRequirementReview,
     openStepDetail,

package/app/stores/workspace.ts

@@ -13,6 +13,7 @@ import { useAgentConfigStore } from '~/stores/agentConfig'
 import { useModelPresetsStore } from '~/stores/modelPresets'
 import { useServiceFragmentDefaultsStore } from '~/stores/serviceFragmentDefaults'
 import { useRecurringPipelinesStore } from '~/stores/recurringPipelines'
+import { useInitiativesStore } from '~/stores/initiative'
 import { useServicesStore } from '~/stores/services'
 import { useAgentsStore } from '~/stores/agents'
 import { useTrackerStore } from '~/stores/tracker'
@@ -82,6 +83,7 @@ export const useWorkspaceStore = defineStore(
         useBrainstormStore().reset()
         useConsensusStore().reset()
         useGitHubStore().reset()
+        useInitiativesStore().reset()
         // The fragment picker catalog is per-board (the merged tenant catalog), so drop
         // it too — the next inspector open re-fetches it for the switched-to board rather
         // than showing the previous board's (or a raw-id placeholder for) fragments.
@@ -109,6 +111,7 @@ export const useWorkspaceStore = defineStore(
       useModelPresetsStore().hydrate(snapshot.modelPresets ?? [])
       useServiceFragmentDefaultsStore().hydrate(snapshot.serviceFragmentDefaults?.fragmentIds)
       useRecurringPipelinesStore().hydrate(snapshot.recurringPipelines ?? [])
+      useInitiativesStore().hydrate(snapshot.initiatives)
       useTrackerStore().hydrate(snapshot.trackerSettings)
       useServicesStore().hydrate(snapshot.mounts ?? [], snapshot.serviceCatalog ?? [])
       // Merge the deployment's registered custom agent kinds into the palette catalog so a

package/app/types/domain.ts

@@ -134,3 +134,4 @@ export type * from './merge'
 export type * from './services'
 export type * from './recurring'
 export type * from './tracker'
+export type * from './initiative'

package/app/types/initiative.ts

@@ -0,0 +1,18 @@
+// Initiative wire shapes, re-exported from the shared contracts package (the single
+// source of truth across the wire boundary). The SPA imports these through
+// `~/types/domain` like every other domain type.
+export type {
+  CreateInitiativeInput,
+  Initiative,
+  InitiativeDecision,
+  InitiativeDeviation,
+  InitiativeEstimate,
+  InitiativeExecutionPolicy,
+  InitiativeFollowUp,
+  InitiativeItem,
+  InitiativeItemStatus,
+  InitiativePhase,
+  InitiativePipelineRule,
+  InitiativeQa,
+  InitiativeStatus,
+} from '@cat-factory/contracts'

package/app/utils/catalog.ts

@@ -344,6 +344,29 @@ export const SYSTEM_AGENT_META: Record<string, AgentArchetype> = {
     color: '#22d3ee',
     description: 'Maps the repository into the service → modules blueprint.',
   },
+  // 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-planner': {
+    kind: 'initiative-planner',
+    label: 'Initiative Planner',
+    icon: 'i-lucide-milestone',
+    color: '#818cf8',
+    description:
+      "Explores the codebase and drafts the initiative's multi-phase plan (items, estimates, concurrency + pipeline policy) for approval.",
+    // Opens the dedicated tracker window (phases / items / policy) instead of the
+    // generic prose step-detail panel.
+    resultView: 'initiative-tracker',
+  },
+  'initiative-committer': {
+    kind: 'initiative-committer',
+    label: 'Initiative Committer',
+    icon: 'i-lucide-git-commit-horizontal',
+    color: '#818cf8',
+    description:
+      'Persists the approved plan and commits the in-repo tracker (docs/initiatives/<slug>/), arming the execution loop. Runs no model.',
+    resultView: 'initiative-tracker',
+  },
   // A read-only repository audit that emits a prioritized findings report. Not a palette
   // archetype (it is only seeded into the recurring tech-debt pipeline), so it lives here
   // for run-timeline / saved-pipeline display rather than in AGENT_ARCHETYPES.
@@ -479,6 +502,7 @@ export const MODEL_CONFIGURABLE_SYSTEM_KINDS: AgentArchetype[] = [
   ...[
     'spec-writer',
     'blueprints',
+    'initiative-planner',
     'conflict-resolver',
     'ci-fixer',
     'fixer',

package/app/utils/initiative.ts

@@ -0,0 +1,57 @@
+import type { InitiativeItem, InitiativeItemStatus, InitiativeStatus } from '~/types/domain'
+
+// Shared initiative presentation vocabulary, so the board card, the inspector body and
+// the tracker window render statuses/progress from ONE source. The exhaustive
+// `Record<Enum, string>` maps keep the tier-2 typecheck guard live (a new status without
+// a label/chip fails the build) without triplicating it across the components.
+
+/** Initiative lifecycle status → i18n label key. */
+export const INITIATIVE_STATUS_LABEL_KEYS: Record<InitiativeStatus, string> = {
+  planning: 'initiative.status.planning',
+  awaiting_approval: 'initiative.status.awaiting_approval',
+  executing: 'initiative.status.executing',
+  paused: 'initiative.status.paused',
+  done: 'initiative.status.done',
+  cancelled: 'initiative.status.cancelled',
+}
+
+/** Initiative lifecycle status → Nuxt UI badge colour. */
+export const INITIATIVE_STATUS_CHIPS: Record<InitiativeStatus, string> = {
+  planning: 'neutral',
+  awaiting_approval: 'warning',
+  executing: 'info',
+  paused: 'neutral',
+  done: 'success',
+  cancelled: 'neutral',
+}
+
+/** Tracker item status → i18n label key. */
+export const INITIATIVE_ITEM_STATUS_LABEL_KEYS: Record<InitiativeItemStatus, string> = {
+  pending: 'initiative.itemStatus.pending',
+  in_progress: 'initiative.itemStatus.in_progress',
+  pr_open: 'initiative.itemStatus.pr_open',
+  done: 'initiative.itemStatus.done',
+  blocked: 'initiative.itemStatus.blocked',
+  skipped: 'initiative.itemStatus.skipped',
+}
+
+/** Tracker item status → Nuxt UI badge colour. */
+export const INITIATIVE_ITEM_STATUS_CHIPS: Record<InitiativeItemStatus, string> = {
+  pending: 'neutral',
+  in_progress: 'info',
+  pr_open: 'warning',
+  done: 'success',
+  blocked: 'error',
+  skipped: 'neutral',
+}
+
+/** Item statuses that count as settled — mirrors the backend terminal-status set. */
+const SETTLED: ReadonlySet<InitiativeItemStatus> = new Set(['done', 'skipped'])
+
+/** Completion rollup across an initiative's items, or null when there are none. */
+export function initiativeProgress(
+  items: InitiativeItem[] | undefined,
+): { settled: number; total: number } | null {
+  if (!items || items.length === 0) return null
+  return { settled: items.filter((i) => SETTLED.has(i.status)).length, total: items.length }
+}

package/i18n/locales/en.json

@@ -275,7 +275,8 @@
       "dragService": "Drag service",
       "dragTask": "Drag task",
       "dragToResize": "Drag to resize",
-      "addFirstTask": "Add the first task"
+      "addFirstTask": "Add the first task",
+      "createInitiativeTitle": "Create initiative"
     },
     "decisionBadge": {
       "decisionNeeded": "Decision needed",
@@ -4071,5 +4072,70 @@
       "saveArchFailed": "Could not save reference architecture",
       "deleteFailed": "Could not delete"
     }
+  },
+  "initiative": {
+    "create": {
+      "title": "Create initiative",
+      "inFrame": "New initiative in {frame}",
+      "titleField": "Title",
+      "titlePlaceholder": "e.g. Migrate the API to the new auth model",
+      "goalField": "Goal",
+      "goalPlaceholder": "Describe the goal, constraints and rough scope. The planner refines this into a multi-phase plan.",
+      "hint": "Nothing runs yet: after creating, run the Initiative Planning pipeline on the block. It analyses the codebase and drafts the multi-phase plan for your approval.",
+      "submit": "Create initiative",
+      "failedTitle": "Could not create the initiative"
+    },
+    "status": {
+      "planning": "Planning",
+      "awaiting_approval": "Awaiting approval",
+      "executing": "Executing",
+      "paused": "Paused",
+      "done": "Done",
+      "cancelled": "Cancelled"
+    },
+    "itemStatus": {
+      "pending": "Pending",
+      "in_progress": "In progress",
+      "pr_open": "PR open",
+      "done": "Done",
+      "blocked": "Blocked",
+      "skipped": "Skipped"
+    },
+    "card": {
+      "kind": "Initiative",
+      "progress": "{done}/{total} items done",
+      "openTracker": "Open tracker"
+    },
+    "tracker": {
+      "title": "Initiative tracker",
+      "subtitle": "Phases, work items, decisions and progress of this initiative",
+      "empty": "No initiative found for this block.",
+      "goal": "Goal",
+      "constraints": "Constraints",
+      "nonGoals": "Non-goals",
+      "analysis": "Codebase analysis",
+      "noPlan": "No plan yet. Run the Initiative Planning pipeline to draft the multi-phase plan.",
+      "phase": "Phase: {title}",
+      "colItem": "Item",
+      "colStatus": "Status",
+      "colPr": "PR",
+      "dependsOn": "Depends on: {items}",
+      "prLink": "PR",
+      "policy": "Execution policy",
+      "maxConcurrent": "Max concurrent tasks: {count}",
+      "defaultPipeline": "Default pipeline:",
+      "axisComplexity": "complexity >= {value}",
+      "axisRisk": "risk >= {value}",
+      "axisImpact": "impact >= {value}",
+      "axisNever": "never matches (no thresholds)",
+      "decisions": "Decisions",
+      "deviations": "Deviations",
+      "followUps": "Follow-ups",
+      "caveats": "Known caveats"
+    },
+    "inspector": {
+      "runPlanning": "Run planning",
+      "hint": "The planning pipeline explores the codebase, drafts the multi-phase plan for approval, then commits the tracker document to the repository."
+    }
   }
 }