@cat-factory/app 0.172.0 → 0.174.0

package/app/composables/useRunReset.ts

@@ -0,0 +1,48 @@
+/**
+ * The confirm-gated "discard this run" action, shared by every surface that offers it so they
+ * can't drift on what it does or how loudly it asks first.
+ *
+ * Destructive and distinct from a STOP: stop halts a run but keeps it readable and retryable,
+ * while this deletes it outright and returns the block to `planned`. That is what makes it the
+ * escape hatch for a WEDGED run — a run whose driver will never settle can't be waited out, and
+ * until the block's `executionId` clears nothing else may start on it.
+ *
+ * Two callers today: the inspector's execution panel (tasks and initiatives alike) and the
+ * initiative planning window, which needs it in-place because a human whose interview stalled is
+ * looking at that window, not at the inspector behind it.
+ */
+export function useRunReset() {
+  const execution = useExecutionStore()
+  const access = useWorkspaceAccess()
+  const { confirm } = useConfirm()
+  const { t } = useI18n()
+
+  /** True while a discard is in flight (drives the button spinner). */
+  const resetting = ref(false)
+
+  /**
+   * Confirm, then discard the block's run. Resolves `true` only when the run was actually
+   * discarded, so a caller can act on it (the planning window closes itself). A read-only viewer
+   * no-ops — every button binding this is disabled for them, and this guards the rest.
+   */
+  async function resetRun(blockId: string): Promise<boolean> {
+    if (resetting.value || !access.canExecuteRuns.value) return false
+    const ok = await confirm({
+      title: t('inspector.execution.resetConfirm.title'),
+      description: t('inspector.execution.resetConfirm.body'),
+      variant: 'destructive',
+      confirmLabel: t('inspector.execution.resetConfirm.confirm'),
+      icon: 'i-lucide-trash-2',
+    })
+    if (!ok) return false
+    resetting.value = true
+    try {
+      await execution.cancel(blockId)
+      return true
+    } finally {
+      resetting.value = false
+    }
+  }
+
+  return { resetting, resetRun }
+}

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

@@ -94,9 +94,15 @@ describe('inspector panel group', () => {
     ])
   })
 
-  it('epic and initiative each show their single inspector', () => {
+  it('an epic shows only its children panel', () => {
     expect(visibleIds(block('epic'))).toEqual(['epic-children'])
-    expect(visibleIds(block('initiative'))).toEqual(['initiative-inspector'])
+  })
+
+  // 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'])
   })
 
   it('no subject selected resolves to no panels', () => {

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

@@ -74,6 +74,14 @@ export interface InspectorPanelSpec {
 
 const isTask = (b: Block) => b.level === 'task'
 const isFrame = (b: Block) => b.level === 'frame'
+/**
+ * A block whose inspector carries a pipeline RUN. An initiative's planning pipeline is an
+ * ordinary run of ordinary agent steps (interviewer → analyst → planner → committer), so it
+ * gets the same execution panel a task does — step list, live phases, step-detail drill-down,
+ * and the Stop / Discard-run controls that are the only way to unwedge a stalled planning run.
+ * 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'
 /** frame OR module — the "container" panels. */
 const isContainer = (b: Block) => b.level === 'frame' || b.level === 'module'
 /**
@@ -106,7 +114,8 @@ export const INSPECTOR_PANEL_SPECS: readonly InspectorPanelSpec[] = [
   { id: 'task-context-docs', order: 10, when: isTask },
   { id: 'task-context-issues', order: 20, when: isTask },
   { id: 'recurring-schedule', order: 30, when: isTask },
-  { id: 'task-execution', order: 40, when: isTask },
+  // Shared with the initiative body — the panel renders a RUN, and an initiative has one.
+  { id: 'task-execution', order: 40, when: hasRuns },
   { id: 'task-estimate', order: 50, when: isTask },
   { id: 'task-dependencies', order: 60, when: isTask },
   { id: 'task-run-settings', order: 70, when: isTask },
@@ -124,5 +133,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' },
-  { id: 'initiative-inspector', order: 210, when: (b) => b.level === 'initiative' },
+  // 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
+  // number only ever competes with the task ids the initiative body doesn't render.
+  { id: 'initiative-inspector', order: 35, when: (b) => b.level === 'initiative' },
 ]

package/app/stores/observability.ts

@@ -119,6 +119,10 @@ export const useObservabilityStore = defineStore('observability', () => {
     if (existing.some((c) => c.id === activity.id)) return
     const row: LlmCallMetric = {
       ...activity,
+      // The live event carries the phase (the proxy knows it) but no turn ordinal — that is
+      // the harness's job-scoped counter, which a proxied call has no equivalent of. Null is
+      // what the stored row will say too, so the live row and the loaded one agree.
+      turnIndex: null,
       promptText: '',
       promptPrefixCount: 0,
       promptHash: '',

package/app/utils/interviewGate.spec.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest'
+import { interviewGatePhase } from './interviewGate'
+
+// `interviewGatePhase` is what stops continue/proceed reading as no-ops in BOTH interview windows
+// (initiative planning, document interview): the resume is asynchronous — the HTTP call only wakes
+// the durable driver, so it returns the PRE-resume entity — and these pin that the RUN status is
+// what distinguishes "parked, waiting on you" from "a pass is running", a distinction the entity
+// alone cannot make.
+
+describe('interviewGatePhase', () => {
+  it('is awaiting while the run is parked on the human', () => {
+    expect(interviewGatePhase('awaiting', 'blocked')).toBe('awaiting')
+  })
+
+  it('is working once the resumed run is running again, even though the entity still says awaiting', () => {
+    // The exact regression: continue/proceed leave the entity's status untouched until the pass
+    // finishes, so an entity-only reading renders the same questions and looks like a dead button.
+    expect(interviewGatePhase('awaiting', 'running')).toBe('working')
+  })
+
+  it('is working for the FIRST pass, before any question exists', () => {
+    expect(interviewGatePhase(undefined, 'running')).toBe('working')
+  })
+
+  it('is failed when the run stopped before the interview settled', () => {
+    // Must not stay `working`: a pass that dies would otherwise spin forever.
+    expect(interviewGatePhase('awaiting', 'failed')).toBe('failed')
+    expect(interviewGatePhase(undefined, 'failed')).toBe('failed')
+  })
+
+  it('is converged once the interview settled, whatever the run went on to do', () => {
+    // `converged` outranks `failed`: a later step's failure belongs to that step, not the
+    // interview, and the block's own failure surface reports it.
+    expect(interviewGatePhase('done', 'running')).toBe('converged')
+    expect(interviewGatePhase('done', 'failed')).toBe('converged')
+    expect(interviewGatePhase('done', undefined)).toBe('converged')
+  })
+
+  it('is idle when the interview never ran', () => {
+    expect(interviewGatePhase(undefined, undefined)).toBe('idle')
+  })
+
+  it('degrades to the entity-only reading when the run is not cached', () => {
+    // A window opened before the execution snapshot lands must show the questions, never a spinner.
+    expect(interviewGatePhase('awaiting', undefined)).toBe('awaiting')
+  })
+
+  it('keeps a paused run answerable', () => {
+    expect(interviewGatePhase('awaiting', 'paused')).toBe('awaiting')
+  })
+})

package/app/utils/interviewGate.ts

@@ -0,0 +1,51 @@
+import type { ExecutionInstance } from '~/types/domain'
+
+// The frontend dual of the backend's shared `InterviewGateController` spine. Both interview gates
+// — the initiative-planning interviewer and the document interviewer — park their run on a
+// decision-wait, expose the SAME `awaiting | done` status on their entity, and resume the same
+// way, so how their windows read "what is happening right now" is shared vocabulary rather than
+// two copies. See `docs/initiatives/clarification-items.md`.
+
+/**
+ * What an interview gate is doing right now, from the human's point of view. Drives the interview
+ * window's body AND (for the initiative) the card/inspector affordances, so the surfaces can't
+ * disagree about whether there is anything to answer.
+ *
+ *  - `idle` — the interview has not run yet (nothing to answer, nothing in flight).
+ *  - `working` — an interviewer pass is running; the human waits.
+ *  - `awaiting` — the run is parked on the human's answers.
+ *  - `converged` — the interview settled; the run moved on.
+ *  - `failed` — the run stopped before the interview settled.
+ */
+export type InterviewGatePhase = 'idle' | 'working' | 'awaiting' | 'converged' | 'failed'
+
+/**
+ * Resolve the phase from the interview entity's status AND its run's status.
+ *
+ * The RUN status is load-bearing, not redundant. Continue/proceed are ASYNC by design: the HTTP
+ * call only records the intent on the parked step and wakes the durable driver, which then runs
+ * the (slow) interviewer LLM — so the response carries the PRE-resume entity, with the same
+ * questions and the same `awaiting` status. Keyed on the entity alone a window is therefore
+ * byte-identical before and after the click, which is indistinguishable from the button doing
+ * nothing for however long the pass takes. A resumed run flips `blocked` → `running` and emits,
+ * so `running` while the interview is unsettled is exactly "a pass is in flight".
+ *
+ * Deriving this from the run rather than a local in-flight flag also survives a reload and cannot
+ * wedge: a pass that FAILS takes the run to `failed`, so the window drops out of `working` and
+ * says so instead of spinning forever. An unknown run (no instance cached yet) degrades to the
+ * entity-only reading, never to a spinner.
+ *
+ * `converged` wins over `failed` on purpose: once the interview settled, a later failure belongs
+ * to the step that failed (the analyst/planner, the writer), and the block's own failure surface
+ * reports it — the interview window claiming the interview broke would be wrong.
+ */
+export function interviewGatePhase(
+  status: 'awaiting' | 'done' | undefined,
+  runStatus: ExecutionInstance['status'] | undefined,
+): InterviewGatePhase {
+  if (status === 'done') return 'converged'
+  if (runStatus === 'failed') return 'failed'
+  if (runStatus === 'running') return 'working'
+  if (status === 'awaiting') return 'awaiting'
+  return 'idle'
+}

package/i18n/locales/de.json

@@ -1259,7 +1259,7 @@
     },
     "execution": {
       "title": "Ausführung",
-      "hint": "Der Live-Lauf der Pipeline dieser Aufgabe: jeder Agent-Schritt, sein Fortschritt und der resultierende Pull Request.",
+      "hint": "Der Live-Lauf der Pipeline: jeder Agent-Schritt, sein Fortschritt und der resultierende Pull Request.",
       "stage": {
         "incorporating": "Wird eingearbeitet…",
         "reviewing": "Wird erneut geprüft…",
@@ -1284,10 +1284,10 @@
       "stop": "Stoppen",
       "stopTooltip": "Den Lauf stoppen, aber behalten (lesbar und wiederholbar)",
       "reset": "Zurücksetzen",
-      "resetTooltip": "Diesen Lauf verwerfen und die Aufgabe auf geplant zurücksetzen",
+      "resetTooltip": "Diesen Lauf verwerfen und den Status auf geplant zurücksetzen",
       "resetConfirm": {
         "title": "Diesen Lauf verwerfen?",
-        "body": "Dies löscht den Lauf und setzt die Aufgabe auf geplant zurück. Dies kann nicht rückgängig gemacht werden.",
+        "body": "Dies löscht den Lauf und setzt den Status auf geplant zurück. Dies kann nicht rückgängig gemacht werden.",
         "confirm": "Lauf verwerfen"
       },
       "mergeConfirm": {
@@ -1622,6 +1622,7 @@
       "deleteRecurringPipeline": "Wiederkehrende Pipeline löschen",
       "deleteTask": "Aufgabe löschen",
       "deleteModule": "Modul löschen",
+      "deleteInitiative": "Initiative löschen",
       "deleteService": "Service löschen",
       "confirmDelete": {
         "task": {
@@ -1632,6 +1633,10 @@
           "title": "Dieses Modul löschen?",
           "body": "\"{name}\" und alles darin wird entfernt. Dies kann nicht rückgängig gemacht werden."
         },
+        "initiative": {
+          "title": "Diese Initiative löschen?",
+          "body": "\"{name}\" und ihr Plan werden entfernt. Bereits erstellte Aufgaben bleiben auf dem Board. Dies kann nicht rückgängig gemacht werden."
+        },
         "service": {
           "title": "Diesen Service löschen?",
           "body": "\"{name}\" und alles darin wird entfernt. Dies kann nicht rückgängig gemacht werden."
@@ -2332,17 +2337,6 @@
       "bestPractices": "Best Practices",
       "bestPracticesHint": "Best-Practice-Fragmente anheften, damit die Agenten dieser Aufgabe sie zusätzlich zu den Standards auf Service-Ebene befolgen.",
       "agentConfiguration": "Agent-Konfiguration",
-      "contextDocuments": "Kontextdokumente",
-      "contextIssues": "Kontext-Issues",
-      "attach": "Anhängen",
-      "connectSource": "Quelle verbinden",
-      "connectSourceNamed": "{source} verbinden",
-      "done": "Fertig",
-      "attachDocDisabledConnect": "Verbinden Sie zuerst eine Dokumentquelle (Integrationen)",
-      "attachDocDisabledEnable": "Aktivieren Sie zuerst die Dokumente-Integration",
-      "attachIssueDisabledConnect": "Verbinden Sie zuerst einen Issue-Tracker (Integrationen)",
-      "attachIssueDisabledEnable": "Aktivieren Sie zuerst die Issue-Tracker-Integration",
-      "importsOnAdd": "importiert beim Hinzufügen",
       "noDocsHint": "Hängen Sie eine Anforderung, ein RFC oder ein PRD an, damit Agenten es beim Implementieren dieser Aufgabe sehen.",
       "noIssuesHint": "Hängen Sie ein Tracker-Issue an, damit Agenten dessen Beschreibung und Kommentare beim Implementieren dieser Aufgabe sehen.",
       "plannedHint": "Die Aufgabe wird in einem geplanten Zustand hinzugefügt. Sie läuft erst, wenn Sie eine Pipeline darauf starten — Sie können sie bis dahin weiter bearbeiten.",
@@ -2508,6 +2502,19 @@
       "noTasksYet": "Noch keine Aufgaben"
     }
   },
+  "contextAttachments": {
+    "documents": "Kontextdokumente",
+    "issues": "Kontext-Issues",
+    "attach": "Anhängen",
+    "done": "Fertig",
+    "connectSource": "Quelle verbinden",
+    "connectSourceNamed": "{source} verbinden",
+    "attachDocDisabledConnect": "Verbinden Sie zuerst eine Dokumentquelle (Integrationen)",
+    "attachDocDisabledEnable": "Aktivieren Sie zuerst die Dokumente-Integration",
+    "attachIssueDisabledConnect": "Verbinden Sie zuerst einen Issue-Tracker (Integrationen)",
+    "attachIssueDisabledEnable": "Aktivieren Sie zuerst die Issue-Tracker-Integration",
+    "importsOnAdd": "importiert beim Hinzufügen"
+  },
   "providers": {
     "presetMismatch": {
       "title": "Preset verwendet nicht verfügbare Modelle",
@@ -2840,7 +2847,8 @@
       "useThisFolder": "Diesen Ordner verwenden",
       "errors": {
         "listDirectory": "Verzeichnis konnte nicht aufgelistet werden"
-      }
+      },
+      "selectAllFiles": "{count} Datei auswählen | Alle {count} Dateien auswählen"
     }
   },
   "personalSubscriptions": {
@@ -3880,7 +3888,19 @@
       "link": "Als lebendes Fragment verknüpfen",
       "githubBrowseHint": "Durchsuchen Sie das Repo und wählen Sie eine oder mehrere zu verknüpfende Dateien.",
       "selectedFiles": "Ausgewählte Dateien ({count})",
-      "removeFile": "Datei entfernen"
+      "removeFile": "Datei entfernen",
+      "blockedReason": {
+        "noSource": "Wählen Sie zuerst oben eine Dokumentquelle aus.",
+        "noRepo": "Wählen Sie ein Repository aus oder fügen Sie oben eine GitHub-Datei- oder Ordner-URL ein.",
+        "noFiles": "Haken Sie im Repository-Browser mindestens eine Datei an.",
+        "noRef": "Geben Sie zuerst eine Seiten-ID oder URL ein."
+      },
+      "urlImport": {
+        "placeholder": "GitHub-Datei- oder Ordner-URL einfügen (z. B. https://github.com/owner/repo/tree/main/docs)",
+        "action": "Suchen",
+        "invalid": "Das sieht nicht nach der URL einer Repository-Datei oder eines Ordners aus.",
+        "notFound": "Kein zugängliches Repository passt zu {slug}. Prüfen Sie die URL oder verbinden Sie das Repository zuerst."
+      }
     },
     "sources": {
       "metaSynced": "synchronisiert · ref {ref}",
@@ -4115,7 +4135,10 @@
       "pathInvalid": "Geben Sie einen Pfad innerhalb des Repositorys an (kein \"..\", keine absoluten Pfade und keine Backslashes).",
       "hint": "Es läuft noch nichts: Führen Sie nach dem Erstellen die Initiative-Planning-Pipeline auf dem Block aus. Sie analysiert die Codebasis und entwirft den mehrphasigen Plan zu Ihrer Freigabe.",
       "submit": "Initiative erstellen",
-      "failedTitle": "Die Initiative konnte nicht erstellt werden"
+      "failedTitle": "Die Initiative konnte nicht erstellt werden",
+      "contextDocsHint": "Hänge eine Anforderung, ein RFC oder ein PRD an, damit die Planungsagenten es beim Abstecken und Entwerfen des Plans lesen.",
+      "contextIssuesHint": "Hänge ein Tracker-Issue an, damit die Planungsagenten beim Entwerfen des Plans seine Beschreibung und Kommentare sehen.",
+      "linkFailed": "Initiative erstellt, aber {count} Anhang konnte nicht verknüpft werden | Initiative erstellt, aber {count} Anhänge konnten nicht verknüpft werden"
     },
     "status": {
       "planning": "Planung",
@@ -4168,6 +4191,7 @@
     "inspector": {
       "runPlanning": "Planung ausführen",
       "answerPlanning": "Planungsfragen beantworten",
+      "planningInProgress": "Planung läuft",
       "pause": "Pausieren",
       "resume": "Fortsetzen",
       "cancel": "Initiative abbrechen",
@@ -4176,13 +4200,23 @@
     "planning": {
       "title": "Die Initiative planen",
       "subtitle": "Beantworten Sie die Fragen des Planers, damit er die Initiative eingrenzen kann",
-      "intro": "Der Planer grenzt diese Initiative ein. Beantworten Sie seine Fragen, um Ziel und Einschränkungen zu formen, dann fahren Sie fort — oder gehen Sie mit dem, was er hat, zur Planung über.",
+      "intro": "Der Planer grenzt diese Initiative ein. Beantworten Sie seine Fragen, um Ziel und Einschränkungen zu formen, und senden Sie sie dann ab. Sie können ihn auch mit dem, was er bereits hat, jetzt planen lassen.",
       "empty": "Keine Initiative für diesen Block gefunden.",
       "converged": "Keine Fragen ausstehend. Der Planer hat, was er braucht, und entwirft den Plan.",
+      "idle": "Die Planung wurde noch nicht gestartet. Führen Sie die Planung von der Initiative aus, um das Interview zu beginnen.",
+      "working": "Der Planer verarbeitet Ihre Antworten",
+      "workingHint": "Das dauert einen Moment. Rückfragen erscheinen hier, sobald er fertig ist, oder er beginnt mit dem Entwurf des Plans, wenn ihm die Angaben genügen.",
+      "failed": "Der Planungslauf wurde abgebrochen",
+      "failedHint": "Er endete, bevor der Planer antworten konnte. Ihre Antworten sind gespeichert; führen Sie die Planung von der Initiative aus erneut aus.",
       "answerPlaceholder": "Ihre Antwort",
-      "hint": "Fortfahren lässt den Planer Rückfragen stellen; Übergehen plant mit den bisherigen Antworten.",
-      "proceed": "Zur Planung übergehen",
-      "continue": "Fortfahren"
+      "hint": "Antworten senden lässt den Planer Rückfragen stellen; Jetzt planen entwirft den Plan mit den bisherigen Antworten.",
+      "unanswered": "Unbeantwortete Fragen: {count}",
+      "proceed": "Jetzt planen",
+      "proceedTitle": "Die restlichen Fragen überspringen und den Plan jetzt entwerfen",
+      "discard": "Lauf verwerfen",
+      "discardTitle": "Den blockierten Planungslauf verwerfen, um die Planung neu zu starten",
+      "continue": "Antworten senden",
+      "continueTitle": "Ihre Antworten senden; der Planer stellt möglicherweise Rückfragen"
     },
     "followUpStatus": {
       "open": "Offen",
@@ -4515,14 +4549,21 @@
   "docInterview": {
     "title": "Das Dokument verfeinern",
     "subtitle": "Beantworte die Fragen des Interviewers, damit er das Dokument formen kann",
-    "intro": "Der Interviewer verfeinert dieses Dokument, bevor es geschrieben wird. Beantworte seine Fragen, um Umfang, Zielgruppe und Struktur zu formen, und fahre dann fort – oder gehe mit dem vorhandenen Stand direkt zum Entwurf über.",
+    "intro": "Der Interviewer verfeinert dieses Dokument, bevor es geschrieben wird. Beantworte seine Fragen, um Umfang, Zielgruppe und Struktur zu formen, und sende sie dann ab. Du kannst ihn auch mit dem vorhandenen Stand jetzt entwerfen lassen.",
     "empty": "Kein Interview für diesen Block gefunden.",
     "brief": "Autoren-Briefing",
     "converged": "Es stehen keine Fragen aus. Der Interviewer hat, was er braucht, und das Dokument wird entworfen.",
+    "working": "Der Interviewer verarbeitet deine Antworten",
+    "workingHint": "Das dauert einen Moment. Nachfragen erscheinen hier, sobald er fertig ist, oder der Entwurf beginnt, wenn ihm die Angaben genügen.",
+    "failed": "Der Dokumentenlauf wurde abgebrochen",
+    "failedHint": "Er endete, bevor der Interviewer antworten konnte. Deine Antworten sind gespeichert; führe die Dokumentaufgabe erneut aus.",
     "answerPlaceholder": "Deine Antwort",
-    "hint": "Mit \"Fortfahren\" kann der Interviewer Nachfragen stellen; mit \"Weiter zum Entwurf\" wird mit den bisherigen Antworten entworfen.",
-    "proceed": "Weiter zum Entwurf",
-    "continue": "Fortfahren",
+    "hint": "Mit \"Antworten senden\" kann der Interviewer Nachfragen stellen; mit \"Jetzt entwerfen\" wird mit den bisherigen Antworten entworfen.",
+    "unanswered": "Unbeantwortete Fragen: {count}",
+    "proceed": "Jetzt entwerfen",
+    "proceedTitle": "Die restlichen Fragen überspringen und den Entwurf jetzt beginnen",
+    "continue": "Antworten senden",
+    "continueTitle": "Deine Antworten senden; der Interviewer stellt möglicherweise Nachfragen",
     "status": {
       "awaiting": "Warten auf Antworten",
       "done": "Fertig"

package/i18n/locales/en.json

@@ -309,17 +309,6 @@
       "bestPractices": "Best practices",
       "bestPracticesHint": "Pin best-practice fragments so this task's agents follow them, on top of the service-level standards.",
       "agentConfiguration": "Agent configuration",
-      "contextDocuments": "Context documents",
-      "contextIssues": "Context issues",
-      "attach": "Attach",
-      "connectSource": "Connect a source",
-      "connectSourceNamed": "Connect {source}",
-      "done": "Done",
-      "attachDocDisabledConnect": "Connect a document source first (Integrations)",
-      "attachDocDisabledEnable": "Enable the documents integration first",
-      "attachIssueDisabledConnect": "Connect an issue tracker first (Integrations)",
-      "attachIssueDisabledEnable": "Enable the issue-tracker integration first",
-      "importsOnAdd": "imports on add",
       "noDocsHint": "Attach a requirement, RFC or PRD so agents see it while implementing this task.",
       "noIssuesHint": "Attach a tracker issue so agents see its description and comments while implementing this task.",
       "plannedHint": "The task is added in a planned state. It won't run until you start a pipeline on it — you can keep editing it until then.",
@@ -500,6 +489,19 @@
       "noTasksYet": "No tasks yet"
     }
   },
+  "contextAttachments": {
+    "documents": "Context documents",
+    "issues": "Context issues",
+    "attach": "Attach",
+    "done": "Done",
+    "connectSource": "Connect a source",
+    "connectSourceNamed": "Connect {source}",
+    "attachDocDisabledConnect": "Connect a document source first (Integrations)",
+    "attachDocDisabledEnable": "Enable the documents integration first",
+    "attachIssueDisabledConnect": "Connect an issue tracker first (Integrations)",
+    "attachIssueDisabledEnable": "Enable the issue-tracker integration first",
+    "importsOnAdd": "imports on add"
+  },
   "errors": {
     "action": {
       "retryFailed": "Retry failed",
@@ -1003,7 +1005,7 @@
     },
     "execution": {
       "title": "Execution",
-      "hint": "The live run of this task's pipeline: each agent step, its progress, and the resulting pull request.",
+      "hint": "The live pipeline run: each agent step, its progress, and the resulting pull request.",
       "stage": {
         "incorporating": "Incorporating…",
         "reviewing": "Re-reviewing…",
@@ -1028,10 +1030,10 @@
       "stop": "Stop",
       "stopTooltip": "Stop the run but keep it (readable and retryable)",
       "reset": "Reset",
-      "resetTooltip": "Discard this run and reset the task to planned",
+      "resetTooltip": "Discard this run and reset the status to planned",
       "resetConfirm": {
         "title": "Discard this run?",
-        "body": "This deletes the run and returns the task to planned. This can't be undone.",
+        "body": "This deletes the run and resets the status to planned. This can't be undone.",
         "confirm": "Discard run"
       },
       "mergeConfirm": {
@@ -1366,6 +1368,7 @@
       "deleteRecurringPipeline": "Delete recurring pipeline",
       "deleteTask": "Delete task",
       "deleteModule": "Delete module",
+      "deleteInitiative": "Delete initiative",
       "deleteService": "Delete service",
       "confirmDelete": {
         "task": {
@@ -1376,6 +1379,10 @@
           "title": "Delete this module?",
           "body": "\"{name}\" and everything inside it will be removed. This can't be undone."
         },
+        "initiative": {
+          "title": "Delete this initiative?",
+          "body": "\"{name}\" and its plan will be removed. Tasks it already created stay on the board. This can't be undone."
+        },
         "service": {
           "title": "Delete this service?",
           "body": "\"{name}\" and everything inside it will be removed. This can't be undone."
@@ -3502,7 +3509,8 @@
       "useThisFolder": "Use this folder",
       "errors": {
         "listDirectory": "Could not list directory"
-      }
+      },
+      "selectAllFiles": "Select {count} file | Select all {count} files"
     }
   },
   "slack": {
@@ -3576,14 +3584,21 @@
   "docInterview": {
     "title": "Refine the document",
     "subtitle": "Answer the interviewer's questions so it can shape the document",
-    "intro": "The interviewer is refining this document before it's written. Answer its questions to shape the scope, audience and structure, then continue — or proceed to draft with what it has.",
+    "intro": "The interviewer is refining this document before it's written. Answer its questions to shape the scope, audience and structure, then submit them. You can also have it draft now with what it already has.",
     "empty": "No interview found for this block.",
     "brief": "Authoring brief",
     "converged": "No questions are pending. The interviewer has what it needs and the document is being drafted.",
+    "working": "The interviewer is working on your answers",
+    "workingHint": "This takes a moment. Follow-up questions appear here when it is done, or drafting starts if it has enough.",
+    "failed": "The document run stopped",
+    "failedHint": "It ended before the interviewer could answer. Your answers are saved; re-run the document task to try again.",
     "answerPlaceholder": "Your answer",
-    "hint": "Continue lets the interviewer ask follow-ups; Proceed drafts with the answers so far.",
-    "proceed": "Proceed to draft",
-    "continue": "Continue",
+    "hint": "Submit answers lets the interviewer ask follow-ups; Draft now writes the document with the answers so far.",
+    "unanswered": "Unanswered questions: {count}",
+    "proceed": "Draft now",
+    "proceedTitle": "Skip the remaining questions and start the draft now",
+    "continue": "Submit answers",
+    "continueTitle": "Send your answers; the interviewer may ask follow-up questions",
     "status": {
       "awaiting": "Awaiting answers",
       "done": "Done"
@@ -5009,7 +5024,19 @@
       "link": "Link as living fragment",
       "githubBrowseHint": "Browse the repo and pick one or more files to link.",
       "selectedFiles": "Selected files ({count})",
-      "removeFile": "Remove file"
+      "removeFile": "Remove file",
+      "blockedReason": {
+        "noSource": "Choose a document source above first.",
+        "noRepo": "Pick a repository, or paste a GitHub file or folder URL above.",
+        "noFiles": "Tick at least one file in the repository browser.",
+        "noRef": "Enter a page id or URL first."
+      },
+      "urlImport": {
+        "placeholder": "Paste a GitHub file or folder URL (e.g. https://github.com/owner/repo/tree/main/docs)",
+        "action": "Find",
+        "invalid": "This doesn't look like a repository file or folder URL.",
+        "notFound": "No accessible repository matches {slug}. Check the URL or connect the repository first."
+      }
     },
     "sources": {
       "metaSynced": "synced · ref {ref}",
@@ -5279,7 +5306,13 @@
       "pathInvalid": "Enter a path inside the repository (no \"..\", absolute paths, or backslashes).",
       "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"
+      "failedTitle": "Could not create the initiative",
+      "contextDocsHint": "Attach a requirement, RFC or PRD so the planning agents read it while scoping and drafting the plan.",
+      "contextIssuesHint": "Attach a tracker issue so the planning agents see its description and comments while drafting the plan.",
+      "linkFailed": "Initiative created, but {count} attachment could not be linked | Initiative created, but {count} attachments could not be linked",
+      "@linkFailed": {
+        "description": "Count-based: how many context attachments (docs/issues) failed to link after the initiative was created (count is always >= 1). Provide ALL plural forms your language needs (English has 2; Polish/Ukrainian need 3 - one/few/many - via the custom pluralRules in i18n.config.ts)."
+      }
     },
     "status": {
       "planning": "Planning",
@@ -5332,6 +5365,7 @@
     "inspector": {
       "runPlanning": "Run planning",
       "answerPlanning": "Answer planning questions",
+      "planningInProgress": "Planning in progress",
       "pause": "Pause",
       "resume": "Resume",
       "cancel": "Cancel initiative",
@@ -5340,13 +5374,23 @@
     "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.",
+      "intro": "The planner is scoping this initiative. Answer its questions to shape the goal and constraints, then submit them. You can also have it plan now with what it already has.",
       "empty": "No initiative found for this block.",
       "converged": "No questions are pending. The planner has what it needs and is drafting the plan.",
+      "idle": "Planning has not started yet. Run planning from the initiative to begin the interview.",
+      "working": "The planner is working on your answers",
+      "workingHint": "This takes a moment. Follow-up questions appear here when it is done, or it starts drafting the plan if it has enough.",
+      "failed": "The planning run stopped",
+      "failedHint": "It ended before the planner could answer. Your answers are saved; re-run planning from the initiative to try again.",
       "answerPlaceholder": "Your answer",
-      "hint": "Continue lets the planner ask follow-ups; Proceed plans with the answers so far.",
-      "proceed": "Proceed to plan",
-      "continue": "Continue"
+      "hint": "Submit answers lets the planner ask follow-ups; Plan now drafts the plan with the answers so far.",
+      "unanswered": "Unanswered questions: {count}",
+      "proceed": "Plan now",
+      "proceedTitle": "Skip the remaining questions and draft the plan now",
+      "discard": "Discard run",
+      "discardTitle": "Discard the stalled planning run so you can start planning again",
+      "continue": "Submit answers",
+      "continueTitle": "Send your answers; the planner may ask follow-up questions"
     },
     "followUpStatus": {
       "open": "Open",