@cat-factory/app 0.180.0 → 0.181.0

package/app/components/tasks/TaskContextIssues.vue

@@ -1,6 +1,10 @@
 <script setup lang="ts">
-// Inspector section for a task block: the tracker issues (Jira, GitHub Issues, …)
-// attached to it as agent context. Attaching uses the SAME inline picker as task
+// Inspector section for a task OR initiative block: the tracker issues (Jira,
+// GitHub Issues, …) attached to it as agent context. An initiative takes the same
+// attachments (the create-initiative modal stages them exactly as the add-task one
+// does) and its whole planning pipeline reads them, so it gets the same section —
+// only the prose differs, which is why the hint/empty copy is level-keyed below.
+// Attaching uses the SAME inline picker as task
 // creation (source selector + in-repo search + paste-by-reference —
 // ContextIssuePicker), NOT the old dropdown that opened a second, page-level
 // "Import an issue…" modal on top of the inspector (stacked page-level modals
@@ -28,6 +32,20 @@ onMounted(() => {
 })
 
 const linked = computed(() => tasks.tasksForBlock(props.block.id))
+
+// Two STATIC literal keys per string, picked by level — the copy names what reads the issue
+// (the agents implementing a task vs the pipeline that plans an initiative), which is the
+// whole point of the hint. Assembling one key from `block.level` would defeat the typed
+// message-key check for a two-member choice that gains nothing from being dynamic.
+const isInitiative = computed(() => props.block.level === 'initiative')
+const hint = computed(() =>
+  isInitiative.value ? t('tasks.contextIssues.hintInitiative') : t('tasks.contextIssues.hint'),
+)
+const emptyHint = computed(() =>
+  isInitiative.value
+    ? t('tasks.contextIssues.emptyHintInitiative')
+    : t('tasks.contextIssues.emptyHint'),
+)
 // Already-linked issues, so the inline picker filters them out / never re-offers them.
 const chosenKeys = computed(() =>
   linked.value.map((issue) =>
@@ -71,7 +89,7 @@ async function attach(item: PendingContext) {
   <InspectorSection
     v-if="tasks.available"
     :title="t('tasks.contextIssues.title')"
-    :hint="t('tasks.contextIssues.hint')"
+    :hint="hint"
     :count="linked.length"
   >
     <template #actions>
@@ -133,7 +151,7 @@ async function attach(item: PendingContext) {
       </a>
     </div>
     <p v-else class="text-[11px] text-slate-500">
-      {{ t('tasks.contextIssues.emptyHint') }}
+      {{ emptyHint }}
     </p>
   </InspectorSection>
 </template>

package/app/composables/useResultViewRunMeta.spec.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest'
+import type { PipelineStep } from '~/types/execution'
+import { resultViewStepIndex } from '~/composables/useResultViewRunMeta'
+
+// The off-path fallback: which step a result window reports run metadata for when it was opened
+// from a board card / the inspector rather than from the run's timeline. The precedence exists
+// because a window's kind set can mix model-running steps with bookkeeping ones — the initiative
+// tracker is registered for the analyst, the planner AND `initiative-committer`, which runs no
+// model — so "the most recent one" alone would anchor on the step with no telemetry.
+
+function step(agentKind: string, overrides: Partial<PipelineStep> = {}): PipelineStep {
+  return { agentKind, state: 'pending', ...overrides } as PipelineStep
+}
+
+/** A step that recorded model calls (the shape `attachStepMetrics` folds onto the run). */
+function metered(agentKind: string, calls: number, startedAt = 1_000): PipelineStep {
+  return step(agentKind, { startedAt, metrics: { calls } as PipelineStep['metrics'] })
+}
+
+describe('resultViewStepIndex', () => {
+  it('is null when no step declares the view', () => {
+    const steps = [step('coder'), step('tester')]
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBeNull()
+  })
+
+  it('falls back to the first declaring step before the run reaches any of them', () => {
+    const steps = [
+      step('initiative-interviewer'),
+      step('initiative-analyst'),
+      step('initiative-planner'),
+    ]
+    // Index 1 — the analyst; the interviewer declares the PLANNING window, not the tracker.
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBe(1)
+  })
+
+  it('prefers the last started step while the run is mid-flight with no telemetry yet', () => {
+    const steps = [
+      step('initiative-interviewer', { startedAt: 10 }),
+      step('initiative-analyst', { startedAt: 20 }),
+      step('initiative-planner'),
+    ]
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBe(1)
+  })
+
+  it('prefers the last step that actually ran a model over a later bookkeeping step', () => {
+    const steps = [
+      metered('initiative-interviewer', 4),
+      metered('initiative-analyst', 12),
+      metered('initiative-planner', 31),
+      // Runs no model, so it records no calls — and must not shadow the planner's telemetry.
+      step('initiative-committer', { startedAt: 2_000 }),
+    ]
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBe(2)
+  })
+
+  it('ignores a metered step belonging to another window', () => {
+    const steps = [metered('initiative-interviewer', 9), step('initiative-analyst')]
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBe(1)
+    expect(resultViewStepIndex(steps, 'initiative-planning')).toBe(0)
+  })
+
+  it('treats a zero-call rollup as unmetered', () => {
+    const steps = [
+      metered('initiative-analyst', 5),
+      step('initiative-planner', {
+        startedAt: 3_000,
+        metrics: { calls: 0 } as PipelineStep['metrics'],
+      }),
+    ]
+    // The analyst keeps the tier-1 match: a rollup that recorded nothing is not telemetry, so
+    // the later step doesn't shadow it just for having a `metrics` object.
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBe(0)
+  })
+})

package/app/composables/useResultViewRunMeta.ts

@@ -0,0 +1,98 @@
+import { computed } from 'vue'
+import type { ExecutionInstance, PipelineStep } from '~/types/execution'
+import { agentKindMeta } from '~/utils/catalog'
+
+/**
+ * Resolves the `StepRunMeta` prop bundle for a dedicated result window, for BOTH of the ways
+ * such a window opens (see `stores/ui/resultViews.ts`):
+ *
+ * - the PIPELINE path (`dispatchStepView`), which carries `instanceId` + `stepIndex` — the step
+ *   is exactly the one that was clicked, as every step-backed window already assumes; and
+ * - an OFF-PATH open (`ui.openInitiativeTracker`, `ui.openInitiativePlanning`, …), which carries
+ *   only a block id, because the human entered from the board card or the inspector rather than
+ *   from the run's timeline.
+ *
+ * Windows that are reachable BOTH ways used to fall back to no metadata at all on the second
+ * route, which is how the initiative windows ended up with no run details, no model and no token
+ * telemetry — on the entry point people actually use. The fallback resolves the block's live run
+ * and picks the step this window represents, so the two routes report the same facts.
+ */
+export function useResultViewRunMeta(
+  viewId: string,
+  source: {
+    blockId: () => string | null
+    instanceId: () => string | null
+    stepIndex: () => number | null
+  },
+) {
+  const execution = useExecutionStore()
+
+  /**
+   * The run the metadata describes: the dispatched one on the pipeline path, else the block's
+   * live run. Read reactively rather than resolved once at open time, so a window left open
+   * across a run start/advance follows it instead of freezing on whatever existed at mount.
+   */
+  const instance = computed<ExecutionInstance | null>(() => {
+    const id = source.instanceId()
+    if (id !== null) return execution.getInstance(id) ?? null
+    const blockId = source.blockId()
+    return blockId ? (execution.getByBlock(blockId) ?? null) : null
+  })
+
+  const stepNumber = computed<number | null>(() => {
+    const index = source.stepIndex()
+    if (index !== null) return index
+    return instance.value ? resultViewStepIndex(instance.value.steps, viewId) : null
+  })
+
+  const step = computed<PipelineStep | null>(() => {
+    const index = stepNumber.value
+    if (index === null) return null
+    return instance.value?.steps[index] ?? null
+  })
+
+  return {
+    instance,
+    step,
+    /** The run id, for the copyable field + the "View all calls" observability link. */
+    instanceId: computed(() => instance.value?.id),
+    /** 1-based position, as `StepRunMeta` renders it ("N of M"). */
+    position: computed(() => (stepNumber.value === null ? undefined : stepNumber.value + 1)),
+    totalSteps: computed(() => instance.value?.steps.length),
+    runFailed: computed(() => instance.value?.status === 'failed'),
+    failureAt: computed(() => instance.value?.failure?.occurredAt),
+  }
+}
+
+/**
+ * The step an off-path open should report, among the run's steps whose agent kind declares
+ * `viewId` as its dedicated result view (the same `resultView` seam `dispatchStepView` routes
+ * on, so the mapping can never drift from the window registry).
+ *
+ * Precedence, most to least specific:
+ *
+ * 1. the last step that has actually RUN A MODEL. A window's kind set can span both model-running
+ *    steps and bookkeeping ones — the initiative tracker is registered for the analyst and the
+ *    planner but also for `initiative-committer`, which runs no model — and anchoring on the last
+ *    STARTED step alone would hand a human who opened the window for its telemetry the one step
+ *    guaranteed to have none.
+ * 2. the last started step, so a run mid-flight (or one whose telemetry sink isn't wired) still
+ *    reports timing, model and run id rather than nothing.
+ * 3. the first declaring step, so a run that hasn't reached any of them yet still names which
+ *    step is coming and how far into the pipeline it sits.
+ *
+ * Null when the run declares none — the caller hides the sidebar rather than rendering an empty one.
+ */
+export function resultViewStepIndex(steps: readonly PipelineStep[], viewId: string): number | null {
+  let first: number | null = null
+  let lastStarted: number | null = null
+  let lastMetered: number | null = null
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i]
+    if (!step || agentKindMeta(step.agentKind).resultView !== viewId) continue
+    if (first === null) first = i
+    if (step.startedAt != null) lastStarted = i
+    if ((step.metrics?.calls ?? 0) > 0) lastMetered = i
+  }
+  return lastMetered ?? lastStarted ?? first
+}

package/app/docs/consumer-extensions.md

@@ -170,16 +170,17 @@ re-deriving the "which run is this / how did the model do" facts. **Composables*
 **components** must be named through the `#components` virtual module (see the boxed note
 below). Compose these:
 
-| Building block         | Reference it as                           | What it gives you                                                                                                                                                                                                                                                                                             |
-| ---------------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ResultWindowShell`    | `#components` → `PanelsResultWindowShell` | The shared modal chrome for a result window — backdrop, header (icon/title/subtitle), a `#header-extras` slot, close button, and the modal _behaviour_ (focus-trap + return, body-scroll lock, shared-stack Escape via `useModalBehavior`). Pass `stepRef` to surface the shared "restart from here" control. |
-| `StepRunMeta`          | `#components` → `PanelsStepRunMeta`       | **The shared run-details metadata block** every agent window reuses: step position, live duration, model, run id, and the LLM model-activity rollup. Drop it into your window's sidebar — never reinvent run metadata.                                                                                        |
-| `MarkdownProse`        | `#components` → `CommonMarkdownProse`     | Render an agent's prose output as markdown.                                                                                                                                                                                                                                                                   |
-| `CopyButton`           | `#components` → `CommonCopyButton`        | The shared copy-to-clipboard affordance.                                                                                                                                                                                                                                                                      |
-| `InspectorSection`     | `#components` → `PanelsInspectorSection`  | The collapsible inspector-section shell (chevron header, count, hint) so a consumer panel reads like a built-in one.                                                                                                                                                                                          |
-| `useResultView(id)`    | auto-imported                             | The window seam contract: `{ open, blockId, instanceId, stepIndex, close }` (+ an `onOpen` loader for windows that fetch, and an `onClose` flush). Escape is owned by the shell, not here.                                                                                                                    |
-| `usePanelSubject<T>()` | `@modular-vue/core`                       | Read the block injected into an inspector panel by `<PanelsOutlet>`.                                                                                                                                                                                                                                          |
-| `useAppOverlays()`     | auto-imported                             | Open / close your own top-level overlays: `{ open(id, subject?), close(), active }`. The store-free seam a nav `run` closure uses to open an `appOverlays`-slot component (see "Top-level overlays").                                                                                                         |
+| Building block                | Reference it as                           | What it gives you                                                                                                                                                                                                                                                                                                                                                                                                |
+| ----------------------------- | ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ResultWindowShell`           | `#components` → `PanelsResultWindowShell` | The shared modal chrome for a result window — backdrop, header (icon/title/subtitle), a `#header-extras` slot, close button, and the modal _behaviour_ (focus-trap + return, body-scroll lock, shared-stack Escape via `useModalBehavior`). Pass `stepRef` to surface the shared "restart from here" control.                                                                                                    |
+| `StepRunMeta`                 | `#components` → `PanelsStepRunMeta`       | **The shared run-details metadata block** every agent window reuses: step position, live duration, model, run id, and the LLM model-activity rollup. Drop it into your window's sidebar — never reinvent run metadata.                                                                                                                                                                                           |
+| `MarkdownProse`               | `#components` → `CommonMarkdownProse`     | Render an agent's prose output as markdown.                                                                                                                                                                                                                                                                                                                                                                      |
+| `CopyButton`                  | `#components` → `CommonCopyButton`        | The shared copy-to-clipboard affordance.                                                                                                                                                                                                                                                                                                                                                                         |
+| `InspectorSection`            | `#components` → `PanelsInspectorSection`  | The collapsible inspector-section shell (chevron header, count, hint) so a consumer panel reads like a built-in one.                                                                                                                                                                                                                                                                                             |
+| `useResultView(id)`           | auto-imported                             | The window seam contract: `{ open, blockId, instanceId, stepIndex, close }` (+ an `onOpen` loader for windows that fetch, and an `onClose` flush). Escape is owned by the shell, not here.                                                                                                                                                                                                                       |
+| `useResultViewRunMeta(id, …)` | auto-imported                             | The `StepRunMeta` prop bundle (`{ step, instanceId, position, totalSteps, runFailed, failureAt }`), resolved for BOTH ways a window opens. A window reachable off-path — from a board card or the inspector — carries no `stepIndex`, so wiring `StepRunMeta` straight off `useResultView` leaves it blank on exactly that route; this resolves the block's live run and the step your view id declares instead. |
+| `usePanelSubject<T>()`        | `@modular-vue/core`                       | Read the block injected into an inspector panel by `<PanelsOutlet>`.                                                                                                                                                                                                                                                                                                                                             |
+| `useAppOverlays()`            | auto-imported                             | Open / close your own top-level overlays: `{ open(id, subject?), close(), active }`. The store-free seam a nav `run` closure uses to open an `appOverlays`-slot component (see "Top-level overlays").                                                                                                                                                                                                            |
 
 > **Reference layer components through `#components`, not bare tags.** Nuxt auto-registers a
 > layer's components under a **path-derived** name (`components/panels/ResultWindowShell.vue`

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

@@ -98,11 +98,18 @@ describe('inspector panel group', () => {
     expect(visibleIds(block('epic'))).toEqual(['epic-children'])
   })
 
-  // An initiative's planning pipeline is an ordinary run, so it shares the task body's execution
-  // panel — its own inspector leading, the run detail under it. Pinned because the panel is the
-  // only surface carrying the Stop / Discard-run controls that unwedge a stalled planning run.
-  it('an initiative shows its inspector, then the shared execution panel', () => {
-    expect(visibleIds(block('initiative'))).toEqual(['initiative-inspector', 'task-execution'])
+  // An initiative shares two of the task body's panels: the CONTEXT sections (the
+  // create-initiative modal attaches the same documents/issues, and the planning pipeline reads
+  // them, so the inspector must surface them) and the execution panel (planning is an ordinary
+  // run — and that panel carries the only Stop / Discard-run controls that unwedge a stalled
+  // one). Order is pinned too: identity + controls, the context it was given, then the run.
+  it('an initiative shows its inspector, then the shared context + execution panels', () => {
+    expect(visibleIds(block('initiative'))).toEqual([
+      'initiative-inspector',
+      'task-context-docs',
+      'task-context-issues',
+      'task-execution',
+    ])
   })
 
   it('no subject selected resolves to no panels', () => {

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

@@ -82,6 +82,14 @@ const isFrame = (b: Block) => b.level === 'frame'
  * Before this it had no run surface at all, which is why a stuck plan was a dead end.
  */
 const hasRuns = (b: Block) => isTask(b) || b.level === 'initiative'
+/**
+ * A block that carries attached CONTEXT (imported documents + tracker issues). The
+ * create-initiative modal stages the same attachments the add-task modal does and links them
+ * to the initiative block, and the whole planning pipeline reads them — so an initiative
+ * whose inspector never showed them left the user with no evidence the attachment landed and
+ * no way to reach the source. Same panels, same store reads (both are keyed by block id only).
+ */
+const takesContext = (b: Block) => isTask(b) || b.level === 'initiative'
 /** frame OR module — the "container" panels. */
 const isContainer = (b: Block) => b.level === 'frame' || b.level === 'module'
 /**
@@ -111,8 +119,9 @@ const isDeployableFrame = (b: Block) => isFrame(b) && b.type !== 'document'
  * extensibility value.
  */
 export const INSPECTOR_PANEL_SPECS: readonly InspectorPanelSpec[] = [
-  { id: 'task-context-docs', order: 10, when: isTask },
-  { id: 'task-context-issues', order: 20, when: isTask },
+  // 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 },
   { id: 'recurring-schedule', order: 30, when: isTask },
   // Shared with the initiative body — the panel renders a RUN, and an initiative has one.
   { id: 'task-execution', order: 40, when: hasRuns },
@@ -133,8 +142,8 @@ export const INSPECTOR_PANEL_SPECS: readonly InspectorPanelSpec[] = [
   // test-infra and release-health panels above it.
   { id: 'service-validation-checks', order: 180, when: isDeployableFrame },
   { id: 'epic-children', order: 200, when: (b) => b.level === 'epic' },
-  // Ordered BEFORE the shared execution panel (40) so an initiative reads the way a task does:
-  // its own identity + controls first, the run detail under them. Levels never overlap, so this
+  // Ordered FIRST so an initiative reads the way a task does: its own identity + controls, then
+  // the context it was given (10/20), then the run detail (40). Levels never overlap, so this
   // number only ever competes with the task ids the initiative body doesn't render.
-  { id: 'initiative-inspector', order: 35, when: (b) => b.level === 'initiative' },
+  { id: 'initiative-inspector', order: 5, when: (b) => b.level === 'initiative' },
 ]

package/i18n/locales/de.json

@@ -3336,10 +3336,12 @@
     "taskDocs": {
       "heading": "Kontextdokumente",
       "hint": "Dokumente, die dieser Aufgabe als Kontext angehängt sind. Ihr Inhalt wird den Agents gegeben, die an der Aufgabe arbeiten.",
+      "hintInitiative": "Dokumente, die dieser Initiative als Kontext angehängt sind. Ihr Inhalt wird den Planungsagenten gegeben, die den Plan entwerfen.",
       "attach": "Anhängen",
       "connectSource": "Quelle verbinden",
       "connectSourceNamed": "{source} verbinden",
       "empty": "Hängen Sie eine Anforderung, ein RFC oder ein PRD an, damit Agents es beim Umsetzen dieser Aufgabe sehen.",
+      "emptyInitiative": "Hängen Sie eine Anforderung, ein RFC oder ein PRD an, damit die Planungsagenten es beim Entwerfen dieser Initiative lesen.",
       "attached": "Dokument angehängt"
     },
     "templates": {
@@ -3382,11 +3384,13 @@
     "contextIssues": {
       "title": "Kontext-Issues",
       "hint": "Tracker-Issues, die dieser Aufgabe als Kontext angehängt sind. Ihr Inhalt wird den Agents gegeben, die an der Aufgabe arbeiten.",
+      "hintInitiative": "Tracker-Issues, die dieser Initiative als Kontext angehängt sind. Ihr Inhalt wird den Planungsagenten gegeben, die den Plan entwerfen.",
       "attach": "Anhängen",
       "connectSource": "Quelle verbinden",
       "connectSourceNamed": "{source} verbinden",
       "attached": "Issue angehängt",
-      "emptyHint": "Hängen Sie ein Jira-Issue an, damit Agents seine Beschreibung und Kommentare beim Umsetzen dieser Aufgabe sehen."
+      "emptyHint": "Hängen Sie ein Jira-Issue an, damit Agents seine Beschreibung und Kommentare beim Umsetzen dieser Aufgabe sehen.",
+      "emptyHintInitiative": "Hängen Sie ein Jira-Issue an, damit die Planungsagenten seine Beschreibung und Kommentare beim Entwerfen dieser Initiative sehen."
     },
     "import": {
       "titleCreate": "Aufgabe aus Issue erstellen",

package/i18n/locales/en.json

@@ -3756,10 +3756,12 @@
     "taskDocs": {
       "heading": "Context documents",
       "hint": "Documents attached to this task as context. Their content is given to the agents that work on the task.",
+      "hintInitiative": "Documents attached to this initiative as context. Their content is given to the planning agents that shape it.",
       "attach": "Attach",
       "connectSource": "Connect a source",
       "connectSourceNamed": "Connect {source}",
       "empty": "Attach a requirement, RFC or PRD so agents see it while implementing this task.",
+      "emptyInitiative": "Attach a requirement, RFC or PRD so the planning agents read it while shaping this initiative.",
       "attached": "Document attached"
     },
     "templates": {
@@ -3802,11 +3804,13 @@
     "contextIssues": {
       "title": "Context issues",
       "hint": "Tracker issues attached to this task as context. Their content is given to the agents that work on the task.",
+      "hintInitiative": "Tracker issues attached to this initiative as context. Their content is given to the planning agents that shape it.",
       "attach": "Attach",
       "connectSource": "Connect a source",
       "connectSourceNamed": "Connect {source}",
       "attached": "Issue attached",
-      "emptyHint": "Attach a Jira issue so agents see its description and comments while implementing this task."
+      "emptyHint": "Attach a Jira issue so agents see its description and comments while implementing this task.",
+      "emptyHintInitiative": "Attach a Jira issue so the planning agents see its description and comments while shaping this initiative."
     },
     "import": {
       "titleCreate": "Create task from issue",

package/i18n/locales/es.json

@@ -3648,10 +3648,12 @@
     "taskDocs": {
       "heading": "Documentos de contexto",
       "hint": "Documentos adjuntos a esta tarea como contexto. Su contenido se entrega a los agentes que trabajan en la tarea.",
+      "hintInitiative": "Documentos adjuntos a esta iniciativa como contexto. Su contenido se entrega a los agentes de planificación que redactan el plan.",
       "attach": "Adjuntar",
       "connectSource": "Conectar una fuente",
       "connectSourceNamed": "Conectar {source}",
       "empty": "Adjunta un requisito, RFC o PRD para que los agentes lo vean mientras implementan esta tarea.",
+      "emptyInitiative": "Adjunta un requisito, RFC o PRD para que los agentes de planificación lo lean al redactar esta iniciativa.",
       "attached": "Documento adjuntado"
     },
     "templates": {
@@ -3694,11 +3696,13 @@
     "contextIssues": {
       "title": "Incidencias de contexto",
       "hint": "Incidencias del tracker adjuntas a esta tarea como contexto. Su contenido se entrega a los agentes que trabajan en la tarea.",
+      "hintInitiative": "Incidencias del tracker adjuntas a esta iniciativa como contexto. Su contenido se entrega a los agentes de planificación que redactan el plan.",
       "attach": "Adjuntar",
       "connectSource": "Conectar una fuente",
       "connectSourceNamed": "Conectar {source}",
       "attached": "Incidencia adjuntada",
-      "emptyHint": "Adjunta una incidencia de Jira para que los agentes vean su descripción y comentarios al implementar esta tarea."
+      "emptyHint": "Adjunta una incidencia de Jira para que los agentes vean su descripción y comentarios al implementar esta tarea.",
+      "emptyHintInitiative": "Adjunta una incidencia de Jira para que los agentes de planificación vean su descripción y comentarios al redactar esta iniciativa."
     },
     "import": {
       "titleCreate": "Crear tarea desde incidencia",

package/i18n/locales/fr.json

@@ -3648,10 +3648,12 @@
     "taskDocs": {
       "heading": "Documents de contexte",
       "hint": "Documents joints à cette tâche comme contexte. Leur contenu est fourni aux agents qui travaillent sur la tâche.",
+      "hintInitiative": "Documents joints à cette initiative comme contexte. Leur contenu est fourni aux agents de planification qui rédigent le plan.",
       "attach": "Joindre",
       "connectSource": "Connecter une source",
       "connectSourceNamed": "Connecter {source}",
       "empty": "Joignez une exigence, un RFC ou un PRD pour que les agents le voient pendant l'implémentation de cette tâche.",
+      "emptyInitiative": "Joignez une exigence, une RFC ou un PRD pour que les agents de planification le lisent en rédigeant cette initiative.",
       "attached": "Document joint"
     },
     "templates": {
@@ -3694,11 +3696,13 @@
     "contextIssues": {
       "title": "Tickets de contexte",
       "hint": "Tickets du tracker joints à cette tâche comme contexte. Leur contenu est fourni aux agents qui travaillent sur la tâche.",
+      "hintInitiative": "Tickets du tracker joints à cette initiative comme contexte. Leur contenu est fourni aux agents de planification qui rédigent le plan.",
       "attach": "Joindre",
       "connectSource": "Connecter une source",
       "connectSourceNamed": "Connecter {source}",
       "attached": "Ticket joint",
-      "emptyHint": "Joignez un ticket Jira pour que les agents voient sa description et ses commentaires lors de l'implémentation de cette tâche."
+      "emptyHint": "Joignez un ticket Jira pour que les agents voient sa description et ses commentaires lors de l'implémentation de cette tâche.",
+      "emptyHintInitiative": "Joignez un ticket Jira pour que les agents de planification voient sa description et ses commentaires en rédigeant cette initiative."
     },
     "import": {
       "titleCreate": "Créer une tâche à partir d'un ticket",

package/i18n/locales/he.json

@@ -3659,10 +3659,12 @@
     "taskDocs": {
       "heading": "מסמכי הקשר",
       "hint": "מסמכים המצורפים למשימה זו כהקשר. תוכנם נמסר לסוכנים שעובדים על המשימה.",
+      "hintInitiative": "מסמכים המצורפים ליוזמה זו כהקשר. תוכנם נמסר לסוכני התכנון שמגבשים את התוכנית.",
       "attach": "צרף",
       "connectSource": "חבר מקור",
       "connectSourceNamed": "חבר את {source}",
       "empty": "צרף דרישה, RFC או PRD כדי שהסוכנים יראו אותם בעת מימוש משימה זו.",
+      "emptyInitiative": "צרף דרישה, RFC או PRD כדי שסוכני התכנון יקראו אותם בעת גיבוש יוזמה זו.",
       "attached": "המסמך צורף"
     },
     "templates": {
@@ -3705,11 +3707,13 @@
     "contextIssues": {
       "title": "ניושני הקשר",
       "hint": "כרטיסי ה-tracker המצורפים למשימה זו כהקשר. תוכנם נמסר לסוכנים שעובדים על המשימה.",
+      "hintInitiative": "כרטיסי ה-tracker המצורפים ליוזמה זו כהקשר. תוכנם נמסר לסוכני התכנון שמגבשים את התוכנית.",
       "attach": "צרף",
       "connectSource": "חבר מקור",
       "connectSourceNamed": "חבר את {source}",
       "attached": "הניושן צורף",
-      "emptyHint": "צרף ניושן Jira כדי שסוכנים יראו את התיאור וההערות שלו בעת מימוש משימה זו."
+      "emptyHint": "צרף ניושן Jira כדי שסוכנים יראו את התיאור וההערות שלו בעת מימוש משימה זו.",
+      "emptyHintInitiative": "צרף ניושן Jira כדי שסוכני התכנון יראו את התיאור וההערות שלו בעת גיבוש יוזמה זו."
     },
     "import": {
       "titleCreate": "צור משימה מניושן",

package/i18n/locales/it.json

@@ -3336,10 +3336,12 @@
     "taskDocs": {
       "heading": "Documenti di contesto",
       "hint": "Documenti allegati a questa attività come contesto. Il loro contenuto viene fornito agli agenti che lavorano sull'attività.",
+      "hintInitiative": "Documenti allegati a questa iniziativa come contesto. Il loro contenuto viene fornito agli agenti di pianificazione che redigono il piano.",
       "attach": "Allega",
       "connectSource": "Collega una fonte",
       "connectSourceNamed": "Collega {source}",
       "empty": "Allega un requisito, un RFC o un PRD così gli agenti lo vedono durante l'implementazione di questa attività.",
+      "emptyInitiative": "Allega un requisito, un RFC o un PRD così gli agenti di pianificazione lo leggono mentre redigono questa iniziativa.",
       "attached": "Documento allegato"
     },
     "templates": {
@@ -3382,11 +3384,13 @@
     "contextIssues": {
       "title": "Issue di contesto",
       "hint": "Issue del tracker allegate a questa attività come contesto. Il loro contenuto viene fornito agli agenti che lavorano sull'attività.",
+      "hintInitiative": "Issue del tracker allegate a questa iniziativa come contesto. Il loro contenuto viene fornito agli agenti di pianificazione che redigono il piano.",
       "attach": "Allega",
       "connectSource": "Collega una fonte",
       "connectSourceNamed": "Collega {source}",
       "attached": "Issue allegata",
-      "emptyHint": "Allega una issue Jira così gli agenti vedono la sua descrizione e i commenti durante l'implementazione di questa attività."
+      "emptyHint": "Allega una issue Jira così gli agenti vedono la sua descrizione e i commenti durante l'implementazione di questa attività.",
+      "emptyHintInitiative": "Allega una issue Jira così gli agenti di pianificazione vedono la sua descrizione e i commenti mentre redigono questa iniziativa."
     },
     "import": {
       "titleCreate": "Crea attività da una issue",

package/i18n/locales/ja.json

@@ -3660,10 +3660,12 @@
     "taskDocs": {
       "heading": "コンテキストドキュメント",
       "hint": "このタスクにコンテキストとして添付されたドキュメント。その内容はタスクに取り組むエージェントに渡されます。",
+      "hintInitiative": "このイニシアチブにコンテキストとして添付されたドキュメント。その内容は計画を作成する計画エージェントに渡されます。",
       "attach": "添付",
       "connectSource": "ソースを接続",
       "connectSourceNamed": "{source} を接続",
       "empty": "要件、RFC、PRD を添付すると、このタスクの実装中にエージェントが参照できます。",
+      "emptyInitiative": "要件、RFC、PRD を添付すると、このイニシアチブの計画作成中に計画エージェントが参照できます。",
       "attached": "ドキュメントを添付しました"
     },
     "templates": {
@@ -3706,11 +3708,13 @@
     "contextIssues": {
       "title": "コンテキスト課題",
       "hint": "このタスクにコンテキストとして添付されたトラッカーの課題。その内容はタスクに取り組むエージェントに渡されます。",
+      "hintInitiative": "このイニシアチブにコンテキストとして添付されたトラッカーの課題。その内容は計画を作成する計画エージェントに渡されます。",
       "attach": "添付",
       "connectSource": "ソースを接続",
       "connectSourceNamed": "{source} を接続",
       "attached": "課題を添付しました",
-      "emptyHint": "Jira 課題を添付すると、このタスクの実装中にエージェントがその説明とコメントを参照できます。"
+      "emptyHint": "Jira 課題を添付すると、このタスクの実装中にエージェントがその説明とコメントを参照できます。",
+      "emptyHintInitiative": "Jira 課題を添付すると、このイニシアチブの計画作成中に計画エージェントがその説明とコメントを参照できます。"
     },
     "import": {
       "titleCreate": "課題からタスクを作成",

package/i18n/locales/pl.json

@@ -3648,10 +3648,12 @@
     "taskDocs": {
       "heading": "Dokumenty kontekstowe",
       "hint": "Dokumenty dołączone do tego zadania jako kontekst. Ich treść trafia do agentów pracujących nad zadaniem.",
+      "hintInitiative": "Dokumenty dołączone do tej inicjatywy jako kontekst. Ich treść trafia do agentów planowania tworzących plan.",
       "attach": "Dołącz",
       "connectSource": "Połącz źródło",
       "connectSourceNamed": "Połącz {source}",
       "empty": "Dołącz wymaganie, dokument RFC lub PRD, aby agenci widzieli je podczas realizacji tego zadania.",
+      "emptyInitiative": "Dołącz wymaganie, dokument RFC lub PRD, aby agenci planowania przeczytali je podczas tworzenia planu tej inicjatywy.",
       "attached": "Dokument dołączony"
     },
     "templates": {
@@ -3694,11 +3696,13 @@
     "contextIssues": {
       "title": "Zgłoszenia kontekstowe",
       "hint": "Zgłoszenia z trackera dołączone do tego zadania jako kontekst. Ich treść trafia do agentów pracujących nad zadaniem.",
+      "hintInitiative": "Zgłoszenia z trackera dołączone do tej inicjatywy jako kontekst. Ich treść trafia do agentów planowania tworzących plan.",
       "attach": "Dołącz",
       "connectSource": "Połącz źródło",
       "connectSourceNamed": "Połącz {source}",
       "attached": "Dołączono zgłoszenie",
-      "emptyHint": "Dołącz zgłoszenie Jira, aby agenci widzieli jego opis i komentarze podczas realizacji tego zadania."
+      "emptyHint": "Dołącz zgłoszenie Jira, aby agenci widzieli jego opis i komentarze podczas realizacji tego zadania.",
+      "emptyHintInitiative": "Dołącz zgłoszenie Jira, aby agenci planowania widzieli jego opis i komentarze podczas tworzenia planu tej inicjatywy."
     },
     "import": {
       "titleCreate": "Utwórz zadanie ze zgłoszenia",

package/i18n/locales/tr.json

@@ -3660,10 +3660,12 @@
     "taskDocs": {
       "heading": "Bağlam belgeleri",
       "hint": "Bu göreve bağlam olarak eklenen belgeler. İçerikleri görev üzerinde çalışan ajanlara iletilir.",
+      "hintInitiative": "Bu girişime bağlam olarak eklenen belgeler. İçerikleri planı hazırlayan planlama ajanlarına iletilir.",
       "attach": "Ekle",
       "connectSource": "Bir kaynak bağla",
       "connectSourceNamed": "{source} bağla",
       "empty": "Agentların bu görevi uygularken görebilmesi için bir gereksinim, RFC veya PRD ekle.",
+      "emptyInitiative": "Planlama ajanlarının bu girişimin planını hazırlarken okuyabilmesi için bir gereksinim, RFC veya PRD ekle.",
       "attached": "Belge eklendi"
     },
     "templates": {
@@ -3706,11 +3708,13 @@
     "contextIssues": {
       "title": "Bağlam sorunları",
       "hint": "Bu göreve bağlam olarak eklenen tracker sorunları. İçerikleri görev üzerinde çalışan ajanlara iletilir.",
+      "hintInitiative": "Bu girişime bağlam olarak eklenen tracker sorunları. İçerikleri planı hazırlayan planlama ajanlarına iletilir.",
       "attach": "Ekle",
       "connectSource": "Bir kaynak bağla",
       "connectSourceNamed": "{source} bağla",
       "attached": "Sorun eklendi",
-      "emptyHint": "Agentların bu görevi uygularken açıklamasını ve yorumlarını görebilmesi için bir Jira sorunu ekle."
+      "emptyHint": "Agentların bu görevi uygularken açıklamasını ve yorumlarını görebilmesi için bir Jira sorunu ekle.",
+      "emptyHintInitiative": "Planlama ajanlarının bu girişimin planını hazırlarken açıklamasını ve yorumlarını görebilmesi için bir Jira sorunu ekle."
     },
     "import": {
       "titleCreate": "Sorundan görev oluştur",