@cat-factory/app 0.182.0 → 0.183.0

package/app/modular/nav-contributions.ts

@@ -30,11 +30,15 @@ export type NavSurface = 'sidebar' | 'command' | 'toolbar'
  *
  * `models` and `integrations` are deliberately SEPARATE sections even though a model
  * provider is technically also an external system we connect to. They answer different
- * questions: `models` is the ENGINE the harnesses run on (no provider ⇒ nothing runs at
- * all), `integrations` is the optional systems that feed a run context or receive its
- * output (source control, trackers, documents, chat, observability) — each of which a
- * deployment can live without. Folding the providers in among them buried the one
- * connection every deployment must make in a list of ones most never touch.
+ * questions: `models` is the MODEL LAYER — which engine the harnesses run on (no provider
+ * ⇒ nothing runs at all), which model each agent kind uses, and how well a given
+ * prompt+agent+model actually performs (`sandbox`, `kaizen`); `integrations` is the
+ * optional EXTERNAL SYSTEMS that feed a run context or receive its output (source control,
+ * trackers, documents, chat, observability) — each of which a deployment can live without.
+ * Folding the providers in among them buried the one connection every deployment must make
+ * in a list of ones most never touch; parking the two model-quality surfaces there was the
+ * same mistake from the other end — neither Sandbox nor Kaizen connects to anything, they
+ * evaluate what the `models` section configures.
  */
 export type NavSidebarGroup =
   | 'create'
@@ -268,33 +272,6 @@ export const NAV_CONTRIBUTIONS: readonly NavContribution[] = [
     testId: 'nav-integrations',
     sidebar: { group: 'integrations', order: 10 },
   },
-  {
-    id: 'sandbox',
-    labelKey: 'nav.sandbox',
-    icon: 'i-lucide-flask-conical',
-    surfaces: S('sidebar', 'command'),
-    advanced: true,
-    gate: (g) => g.canManageIntegrations,
-    action: 'sandbox',
-    testId: 'nav-sandbox',
-    sidebar: { group: 'integrations', order: 20 },
-    command: {
-      group: 'workspace',
-      order: 70,
-      labelKey: 'layout.commandBar.cmd.sandbox',
-      keywordsKey: 'layout.commandBar.keywords.sandbox',
-    },
-  },
-  {
-    id: 'kaizen',
-    labelKey: 'nav.kaizen',
-    icon: 'i-lucide-sparkles',
-    surfaces: S('sidebar'),
-    advanced: true,
-    action: 'kaizen',
-    testId: 'nav-kaizen',
-    sidebar: { group: 'integrations', order: 30 },
-  },
   {
     id: 'infrastructure',
     labelKey: 'nav.infrastructure',
@@ -370,6 +347,39 @@ export const NAV_CONTRIBUTIONS: readonly NavContribution[] = [
       keywordsKey: 'layout.commandBar.keywords.modelConfiguration',
     },
   },
+  {
+    // Trying prompt versions and models against graded fixtures — a model-layer surface,
+    // not an integration: it connects to no external system, it exercises the providers
+    // and per-agent models the two entries above configure.
+    id: 'sandbox',
+    labelKey: 'nav.sandbox',
+    icon: 'i-lucide-flask-conical',
+    surfaces: S('sidebar', 'command'),
+    advanced: true,
+    gate: (g) => g.canManageIntegrations,
+    action: 'sandbox',
+    testId: 'nav-sandbox',
+    sidebar: { group: 'models', order: 30 },
+    command: {
+      group: 'workspace',
+      order: 70,
+      labelKey: 'layout.commandBar.cmd.sandbox',
+      keywordsKey: 'layout.commandBar.keywords.sandbox',
+    },
+  },
+  {
+    // The same axis after the fact: grading history and verified prompt+agent+model combos.
+    // Sandbox asks "which combination should we use", Kaizen answers "how is the one we
+    // shipped doing" — both read the model layer, so they sit with it.
+    id: 'kaizen',
+    labelKey: 'nav.kaizen',
+    icon: 'i-lucide-sparkles',
+    surfaces: S('sidebar'),
+    advanced: true,
+    action: 'kaizen',
+    testId: 'nav-kaizen',
+    sidebar: { group: 'models', order: 40 },
+  },
   {
     id: 'service-fragment-defaults',
     labelKey: 'layout.commandBar.cmd.serviceFragmentDefaults',

package/app/pages/index.vue

@@ -437,7 +437,6 @@ watch(
       <WorkspaceSettingsPanel v-if="ui.workspaceSettingsOpen" />
       <AccountSettingsPanel v-if="ui.accountSettingsOpen" />
       <ObservabilityConnectionPanel v-if="ui.observabilityConnectionOpen" />
-      <PackageRegistriesPanel v-if="ui.packageRegistriesOpen" />
       <ApiTokensPanel v-if="ui.apiTokensOpen" />
       <InfrastructureWindow v-if="ui.infrastructureOpen" />
       <EnvironmentSetupWizard v-if="ui.environmentWizardOpen" />

package/app/stores/packageRegistries.spec.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { usePackageRegistriesStore } from '~/stores/packageRegistries'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { PackageRegistryEntryView } from '~/types/packageRegistries'
+
+/**
+ * The availability probe and the list read share one `load()`, but their failure contracts are
+ * opposite, and the split is what these cases pin:
+ *
+ *   - a 503 is an ANSWER ("this deployment has no registries module") and resolves normally, so
+ *     the Infrastructure window simply shows no tab;
+ *   - anything else is a FAILURE that propagates, because the panel — which only renders once
+ *     the probe already succeeded — is the surface that can tell a reader the list they are
+ *     looking at could not be fetched.
+ */
+function entry(over: Partial<PackageRegistryEntryView> = {}): PackageRegistryEntryView {
+  return {
+    id: 'pkgreg_1',
+    ecosystem: 'npm',
+    vendor: 'npmjs',
+    scopes: ['@acme'],
+    tokenTail: 'cdef',
+    ...over,
+  }
+}
+
+describe('packageRegistries store', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('load stores the entries and marks the module available', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listPackageRegistries: () => Promise.resolve({ entries: [entry()] }),
+    }))
+
+    const store = usePackageRegistriesStore()
+    await store.load()
+
+    expect(store.available).toBe(true)
+    expect(store.entries).toHaveLength(1)
+    expect(store.loading).toBe(false)
+  })
+
+  it('a definitive 503 latches the module unavailable without throwing', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listPackageRegistries: () => Promise.reject({ statusCode: 503 }),
+    }))
+
+    const store = usePackageRegistriesStore()
+    await expect(store.load()).resolves.toBeUndefined()
+
+    expect(store.available).toBe(false)
+    expect(store.entries).toEqual([])
+  })
+
+  it('a transient failure propagates and leaves `available` null so the probe stays retryable', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listPackageRegistries: () => Promise.reject({ statusCode: 500 }),
+    }))
+
+    const store = usePackageRegistriesStore()
+    await expect(store.load()).rejects.toMatchObject({ statusCode: 500 })
+
+    // Never cached as a false "unavailable": a reachable-but-flaky backend must not hide a tab
+    // the deployment really has.
+    expect(store.available).toBeNull()
+    expect(store.loading).toBe(false)
+  })
+
+  it('keeps an already-loaded list when a later refresh fails', async () => {
+    let fail = false
+    vi.stubGlobal('useApi', () => ({
+      listPackageRegistries: () =>
+        fail ? Promise.reject({ statusCode: 500 }) : Promise.resolve({ entries: [entry()] }),
+    }))
+
+    const store = usePackageRegistriesStore()
+    await store.load()
+    fail = true
+    await expect(store.load()).rejects.toMatchObject({ statusCode: 500 })
+
+    // The panel reports the failure; it must not also blank the list the reader had.
+    expect(store.available).toBe(true)
+    expect(store.entries).toHaveLength(1)
+  })
+
+  it('ensureLoaded probes once and stays retryable after a transient failure', async () => {
+    let calls = 0
+    let fail = true
+    vi.stubGlobal('useApi', () => ({
+      listPackageRegistries: () => {
+        calls += 1
+        return fail ? Promise.reject({ statusCode: 500 }) : Promise.resolve({ entries: [] })
+      },
+    }))
+
+    const store = usePackageRegistriesStore()
+    await expect(store.ensureLoaded()).rejects.toMatchObject({ statusCode: 500 })
+    expect(calls).toBe(1)
+
+    fail = false
+    await store.ensureLoaded()
+    expect(calls).toBe(2)
+    expect(store.available).toBe(true)
+
+    // Settled now, so a third caller costs no request.
+    await store.ensureLoaded()
+    expect(calls).toBe(2)
+  })
+})

package/app/stores/packageRegistries.ts

@@ -7,8 +7,9 @@ import { apiErrorStatus } from '~/composables/api/errors'
 /**
  * The workspace's private package-registry entries (npm private orgs, GitHub
  * Packages) that agent containers install with. Tokens are write-only — the store
- * only ever holds the redacted summary views. Loaded on demand (the registries
- * panel + the Integrations hub badge), not from the snapshot.
+ * only ever holds the redacted summary views. Loaded on demand (the Infrastructure
+ * window's "Package registries" tab, whose very existence gates on the probe below),
+ * not from the snapshot.
  */
 export const usePackageRegistriesStore = defineStore('packageRegistries', () => {
   const api = useApi()
@@ -16,8 +17,8 @@ export const usePackageRegistriesStore = defineStore('packageRegistries', () =>
   const entries = ref<PackageRegistryEntryView[]>([])
   const loading = ref(false)
   // Mirrors the backend's opt-in gate (the module 503s when the encryption key is
-  // absent): `null` until first probed, then `true`/`false`. The hub hides its
-  // registries entry point when this is false.
+  // absent): `null` until first probed, then `true`/`false`. The Infrastructure window
+  // shows no registries tab unless this is `true`.
   const available = ref<boolean | null>(null)
   let inFlight: Promise<void> | null = null
 
@@ -31,13 +32,25 @@ export const usePackageRegistriesStore = defineStore('packageRegistries', () =>
     } catch (err) {
       if (apiErrorStatus(err) === 503) {
         // A definitive 503 means the integration is unconfigured (no encryption key on
-        // the backend): hide the UI entry points and stop probing.
+        // the backend): hide the UI entry points and stop probing. This is an ANSWER, not a
+        // failure, so it resolves normally.
         available.value = false
         entries.value = []
+        return
       }
-      // Any other failure (transient 5xx / network) is left untouched: it must not hide
-      // an already-available panel nor cache a false "unavailable". `available` stays
-      // `null` when never probed, so `ensureLoaded` remains retryable on the next open.
+      // Any other failure (transient 5xx / network) leaves the state untouched: it must not
+      // hide an already-available panel nor cache a false "unavailable". `available` stays
+      // `null` when never probed, so `ensureLoaded` remains retryable on the next open — and
+      // the error PROPAGATES so a caller can say so. Swallowing it made every caller's error
+      // branch dead code: "the backend is unreachable" and "your deployment has no registries
+      // module" are different problems that must not render identically, and the panel is the
+      // one surface that can tell a reader which it hit. The PROBE callers still swallow (a
+      // failed probe means no tab, not a broken window) — the split is deliberate.
+      //
+      // NB `publicApiKeys` carries the same availability shape and still swallows here. It is
+      // not being changed alongside: its probe only hides one row of a hub full of others,
+      // whereas this one gates the feature's ONLY surface.
+      throw err
     } finally {
       loading.value = false
     }

package/app/stores/ui/modals.ts

@@ -1,5 +1,6 @@
 import { ref } from 'vue'
 import type { DocumentSourceKind, InfraSetupArea, TaskSourceKind } from '~/types/domain'
+import type { InfrastructureTab, ProviderConnectionKind } from '~/types/providerConnections'
 import type { PendingContext } from '~/composables/useContextLinking'
 import {
   DEFAULT_PROVISION_DEEP_LINK_PARAM,
@@ -452,9 +453,8 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
   // model / agent kind, spend + activity per workspace / service / task type). Admin-gated.
   // Distinct from `operatorDashboardOpen`, which answers the deployment-HEALTH question.
   const reportsOpen = ref(false)
-  // Private package registries: the workspace's npm/GitHub-Packages entries agent
-  // containers install with. Opened from the Integrations hub.
-  const packageRegistriesOpen = ref(false)
+  // NOTE: private package registries are no longer a panel of their own — they are a tab of
+  // the Infrastructure window (`infrastructureOpen`), reached from the navbar.
   // API access tokens: the workspace's inbound public-API keys external systems present to
   // the `/api/v1` surface. Opened from the Integrations hub.
   const apiTokensOpen = ref(false)
@@ -505,13 +505,6 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
   function closeReports() {
     reportsOpen.value = false
   }
-  function openPackageRegistries() {
-    resetHubReturn()
-    packageRegistriesOpen.value = true
-  }
-  function closePackageRegistries() {
-    packageRegistriesOpen.value = false
-  }
   function openApiTokens() {
     resetHubReturn()
     apiTokensOpen.value = true
@@ -564,7 +557,6 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
     observabilityConnectionOpen,
     operatorDashboardOpen,
     reportsOpen,
-    packageRegistriesOpen,
     apiTokensOpen,
     modelConfigOpen,
     vendorCredentialsOpen,
@@ -582,8 +574,6 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
     openReports,
     closeReports,
     closeOperatorDashboard,
-    openPackageRegistries,
-    closePackageRegistries,
     openApiTokens,
     closeApiTokens,
     openModelConfig,
@@ -683,13 +673,19 @@ function createSettingsModals(resetHubReturn: ResetHubReturn) {
  */
 function createInfraModals(resetHubReturn: ResetHubReturn) {
   // The single tabbed Infrastructure window — a TOP-LEVEL navbar destination (no longer
-  // reached via the Integrations hub). Two topical tabs: "Agent containers" (the execution
-  // backend + self-hosted runner pool, plus the local-mode warm pool/checkout) and "Test
-  // environments" (the ephemeral-environment provider). `infrastructureOpen` is the modal
-  // flag; `infrastructureTab` selects the tab. `openInfrastructure()` is the navbar entry;
-  // `openProviderConnection(kind)` remains for deep-links (a banner's "Configure…" button).
+  // reached via the Integrations hub). Its topical tabs: "Agent containers" (the execution
+  // backend + self-hosted runner pool, plus the local-mode warm pool/checkout), "Test
+  // environments" (the ephemeral-environment provider), "Shared stacks" (long-lived Compose
+  // infra an environment attaches to) and "Package registries" (the private registries a
+  // checkout installs from). `infrastructureOpen` is the modal flag; `infrastructureTab`
+  // selects the tab. `openInfrastructure()` is the navbar entry; `openProviderConnection(kind)`
+  // remains for deep-links (a banner's "Configure…" button).
+  //
+  // The ref is typed against the FULL `InfrastructureTab` union, not the provider-connection
+  // kinds: a tab this cannot name is a tab nothing can deep-link to, which is how the
+  // non-connection tabs ended up reachable only by opening the window and clicking across.
   const infrastructureOpen = ref(false)
-  const infrastructureTab = ref<'environment' | 'runner-pool'>('runner-pool')
+  const infrastructureTab = ref<InfrastructureTab>('runner-pool')
   // Non-secret prefill captured from the `cat-factory k3s` CLI deep-link (see
   // `consumeK3sSetupDeepLink`). When set, the Test-environments tab's kube engine form seeds the
   // `local-k3s` connection from it; the ServiceAccount token is deliberately NOT in the link (a
@@ -704,12 +700,15 @@ function createInfraModals(resetHubReturn: ResetHubReturn) {
 
   // Top-level navbar entry into the Infrastructure window. No hub-return marker (it isn't
   // reached from the Integrations hub), so the window shows no "Back to Integrations" control.
-  function openInfrastructure(tab: 'environment' | 'runner-pool' = 'runner-pool') {
+  function openInfrastructure(tab: InfrastructureTab = 'runner-pool') {
     resetHubReturn()
     infrastructureTab.value = tab
     infrastructureOpen.value = true
   }
-  function openProviderConnection(kind: 'environment' | 'runner-pool') {
+  // Deep-link into a PROVIDER's tab specifically (a config banner's "Configure…" button), so
+  // this one stays narrowed to the connection kinds — it means "connect this provider", not
+  // "open the window somewhere". Use `openInfrastructure(tab)` for any other tab.
+  function openProviderConnection(kind: ProviderConnectionKind) {
     resetHubReturn()
     infrastructureTab.value = kind
     infrastructureOpen.value = true

package/app/types/providerConnections.ts

@@ -17,6 +17,18 @@ export type {
 /** The two infrastructure providers configured through the generic connect form. */
 export type ProviderConnectionKind = 'environment' | 'runner-pool'
 
+/**
+ * A tab of the Infrastructure window, and the vocabulary `ui.infrastructureTab` selects from.
+ *
+ * Deliberately WIDER than {@link ProviderConnectionKind}: the window also hosts tabs that are
+ * not a provider connection at all (long-lived shared Compose stacks, the workspace's private
+ * package registries). Typing the store's tab ref as the connection kinds alone is what made
+ * those tabs unreachable by deep link — a banner, a command-palette entry or an Integrations-hub
+ * pointer could open the window but never land the user on the tab it meant. Every tab
+ * `InfrastructureWindow.vue` can render must have a name here.
+ */
+export type InfrastructureTab = ProviderConnectionKind | 'shared-stacks' | 'package-registries'
+
 /** A workspace's provider binding, as exposed to clients (never secret values). */
 export interface ProviderConnection {
   /** The runner-backend kind for a runner-pool connection (`manifest` | `kubernetes`). */

package/app/utils/initiative.spec.ts

@@ -1,7 +1,12 @@
 import { INITIATIVE_ITEM_TERMINAL_STATUSES } from '@cat-factory/contracts'
 import { describe, it, expect } from 'vitest'
 import type { InitiativeItem, InitiativePhase, InitiativeQa } from '~/types/domain'
-import { isPendingQuestion, orderInterviewQuestions, pendingCheckpointPhase } from './initiative'
+import {
+  isPendingQuestion,
+  orderInterviewQuestions,
+  pendingCheckpointPhase,
+  selectPlanApproval,
+} from './initiative'
 
 // `pendingCheckpointPhase` mirrors the backend `pendingCheckpoint` (orchestration
 // `initiative.logic.ts`); these pin the same ordering/edge cases the loop pauses on, so the
@@ -150,3 +155,48 @@ describe('orderInterviewQuestions', () => {
     expect(orderInterviewQuestions([])).toEqual([])
   })
 })
+
+// The plan-review park: which of a block's pending approvals the board card / inspector offer as
+// "Review plan", and which one they must leave alone. Both gates on the planning pipeline park on
+// a `step.approval`, so the interviewer's park (owned by the planning window's "Answer planning
+// questions") is the case this selector exists to keep out — offering it here would give one park
+// two differently-worded buttons, and the tracker window it opened could not resolve it.
+
+/** A pending approval as `execution.approvalsByBlock` carries it (only the fields read here). */
+const parked = (agentKind: string, id: string) => ({ agentKind, approval: { id } })
+
+/** The catalog's result-view resolver, as the composable passes it in. */
+const resultViewOf = (kind: string): string | undefined =>
+  kind === 'initiative-interviewer'
+    ? 'initiative-planning'
+    : kind.startsWith('initiative-')
+      ? 'initiative-tracker'
+      : undefined
+
+describe('selectPlanApproval', () => {
+  it('is undefined when nothing is parked', () => {
+    expect(selectPlanApproval([], resultViewOf)).toBeUndefined()
+  })
+
+  it('picks the planner gate — the plan awaiting approval', () => {
+    const approvals = [parked('initiative-planner', 'ap_1')]
+    expect(selectPlanApproval(approvals, resultViewOf)?.approval.id).toBe('ap_1')
+  })
+
+  it('leaves the interviewer park to the planning window', () => {
+    const approvals = [parked('initiative-interviewer', 'ap_interview')]
+    expect(selectPlanApproval(approvals, resultViewOf)).toBeUndefined()
+  })
+
+  it('finds the plan gate past an interview park (a re-run interviewing again)', () => {
+    const approvals = [parked('initiative-interviewer', 'ap_interview'), parked('x', 'ap_plan')]
+    expect(selectPlanApproval(approvals, resultViewOf)?.approval.id).toBe('ap_plan')
+  })
+
+  it('offers a gated step of a custom planning pipeline, whatever window it routes to', () => {
+    // A kind with no dedicated window at all still parks a human; the affordance opens whatever
+    // `dispatchStepView` routes it to (the generic panel), which is exactly what resolves it.
+    const approvals = [parked('some-custom-kind', 'ap_custom')]
+    expect(selectPlanApproval(approvals, resultViewOf)?.approval.id).toBe('ap_custom')
+  })
+})

package/app/utils/initiative.ts

@@ -59,6 +59,50 @@ export const INITIATIVE_ITEM_STATUS_CHIPS: Record<InitiativeItemStatus, BadgeCol
   skipped: 'neutral',
 }
 
+/**
+ * The two ways an initiative's planning run parks for a human: an agent-raised `decision`, or a
+ * pending step `approval` (the plan-approval gate the `initiative-planner` step carries). Resolved
+ * per block by `useInitiativePlanning().attention`.
+ */
+export type InitiativeAttentionKind = 'decision' | 'approval'
+
+/** Park kind → i18n label key for the card/inspector button that opens the resolving window. */
+export const INITIATIVE_ATTENTION_LABEL_KEYS: Record<InitiativeAttentionKind, string> = {
+  decision: 'initiative.inspector.resolveDecision',
+  approval: 'initiative.inspector.reviewPlan',
+}
+
+/** Park kind → button icon, so the board card and the inspector can't diverge on one park. */
+export const INITIATIVE_ATTENTION_ICONS: Record<InitiativeAttentionKind, string> = {
+  decision: 'i-lucide-circle-help',
+  approval: 'i-lucide-clipboard-check',
+}
+
+/**
+ * The result view the INTERVIEW gate owns. Its park rides the same `step.approval` mechanism as
+ * every other gate, so anything offering "there is a plan to review here" has to exclude it: the
+ * interview park is already owned by the planning window, behind the differently-worded "Answer
+ * planning questions".
+ */
+export const INTERVIEW_GATE_RESULT_VIEW = 'initiative-planning'
+
+/**
+ * The block's parked approval that is a PLAN REVIEW — the planner's human gate (`pl_initiative`
+ * declares `{ kind: 'initiative-planner', gate: true }`), or any other gated step of a custom
+ * planning pipeline — as opposed to the interviewer's park.
+ *
+ * Discriminated by the step's own result view, the seam `dispatchStepView` routes on, rather than
+ * by an agent-kind list or by the interview phase: the affordance's ACTION is that dispatch, so
+ * keying the offer on the same fact guarantees the button opens a window that can resolve what it
+ * offered — and that the interview and plan affordances can never both claim one park.
+ */
+export function selectPlanApproval<A extends { agentKind: string }>(
+  approvals: readonly A[],
+  resultViewOf: (agentKind: string) => string | undefined,
+): A | undefined {
+  return approvals.find((a) => resultViewOf(a.agentKind) !== INTERVIEW_GATE_RESULT_VIEW)
+}
+
 /** Follow-up triage status → i18n label key. Exhaustive so a new status fails the build. */
 export const INITIATIVE_FOLLOWUP_STATUS_LABEL_KEYS: Record<InitiativeFollowUp['status'], string> = {
   open: 'initiative.followUpStatus.open',

package/i18n/locales/de.json

@@ -537,20 +537,22 @@
       "incidentNoun": "der Incident-Provider"
     },
     "packageRegistries": {
-      "title": "Private Package-Registries",
+      "tab": "Package-Registries",
       "intro": "Verbinde die privaten Registries, aus denen deine Repositories installieren. Agenten erhalten sie beim Auschecken eines Repositorys, sodass private Abhängigkeiten während der Installation aufgelöst werden. Tokens sind nur schreibbar: um eines zu ändern, entferne den Eintrag und füge ihn erneut hinzu.",
       "entryNoun": "Registry-Eintrag",
       "list": {
         "heading": "Verbundene Registries",
         "tokenTail": "Token …{tail}",
-        "remove": "Eintrag entfernen"
+        "remove": "Eintrag entfernen",
+        "noScopes": "Keine Scopes (das Token authentifiziert nur dieses Registry)"
       },
       "add": {
         "heading": "Eine Registry hinzufügen",
         "vendor": "Registry",
         "host": "Das Token wird nur an {host} gesendet.",
         "scopes": "Package-Scopes",
-        "scopesHelp": "Kommagetrennte npm-Scopes",
+        "scopesHelp": "Optional. Kommagetrennte npm-Scopes.",
+        "scopesNote": "Optional. Ein hier eingetragener Scope leitet jedes Paket darunter an dieses Registry, sodass ein Scope, der auch öffentlich veröffentlichte Pakete enthält, nicht mehr aufgelöst wird. Lass das Feld leer, wenn das Repository eine eigene .npmrc enthält oder wenn einzelne Abhängigkeiten über ein benanntes Registry-Präfix wie gh: festgelegt werden (pnpm 11.1 oder neuer) - das Token authentifiziert das Registry ohnehin.",
         "token": "Zugriffstoken",
         "save": "Registry hinzufügen"
       },
@@ -2147,10 +2149,6 @@
           "label": "Post-Release-Health",
           "description": "Überwachen Sie Monitore und SLOs, nachdem ein Release ausgeliefert wurde (Datadog)."
         },
-        "packageRegistries": {
-          "label": "Private Package-Registries",
-          "description": "npm- und GitHub-Packages-Tokens, mit denen Agenten private Abhängigkeiten installieren."
-        },
         "apiTokens": {
           "label": "API-Zugriffstokens",
           "description": "Tokens, die externe Systeme vorlegen, um die cat-factory-API aufzurufen."
@@ -4282,12 +4280,22 @@
     "inspector": {
       "runPlanning": "Planung ausführen",
       "answerPlanning": "Planungsfragen beantworten",
+      "reviewPlan": "Plan prüfen",
+      "resolveDecision": "Auflösen",
       "planningInProgress": "Planung läuft",
       "pause": "Pausieren",
       "resume": "Fortsetzen",
       "cancel": "Initiative abbrechen",
       "hint": "Die Planning-Pipeline erkundet die Codebasis, entwirft den mehrphasigen Plan zur Freigabe und committet dann das Tracker-Dokument ins Repository."
     },
+    "planReview": {
+      "title": "Dieser Plan wartet auf dich",
+      "body": "Der Planner hat die Phasen und Aufgaben unten entworfen. Gib sie frei, um den Plan zu committen und die Arbeit zu starten, oder schicke den Plan mit deinen Änderungswünschen zurück.",
+      "approve": "Plan freigeben",
+      "requestChanges": "Änderungen anfordern",
+      "feedbackPlaceholder": "Was soll der Planner ändern? Umfang, Reihenfolge der Phasen, fehlende Arbeit, eine Aufgabe, die woanders hingehört …",
+      "sendBack": "An den Planner zurückschicken"
+    },
     "planning": {
       "title": "Die Initiative planen",
       "subtitle": "Beantworten Sie die Fragen des Planers, damit er die Initiative eingrenzen kann",

package/i18n/locales/en.json

@@ -2163,10 +2163,6 @@
           "label": "Post-release health",
           "description": "Watch monitors and SLOs after a release ships (Datadog)."
         },
-        "packageRegistries": {
-          "label": "Private package registries",
-          "description": "npm and GitHub Packages tokens agents use to install private dependencies."
-        },
         "apiTokens": {
           "label": "API access tokens",
           "description": "Tokens external systems present to call the cat-factory API."
@@ -2813,20 +2809,22 @@
       "incidentNoun": "the incident provider"
     },
     "packageRegistries": {
-      "title": "Private package registries",
+      "tab": "Package registries",
       "intro": "Connect the private registries your repositories install from. Agents receive them when they check out a repository, so private dependencies resolve during installs. Tokens are write-only: to change one, remove the entry and add it again.",
       "entryNoun": "registry entry",
       "list": {
         "heading": "Connected registries",
         "tokenTail": "token …{tail}",
-        "remove": "Remove entry"
+        "remove": "Remove entry",
+        "noScopes": "No scopes (the token authenticates this registry only)"
       },
       "add": {
         "heading": "Add a registry",
         "vendor": "Registry",
         "host": "The token is sent only to {host}.",
         "scopes": "Package scopes",
-        "scopesHelp": "Comma-separated npm scopes",
+        "scopesHelp": "Optional. Comma-separated npm scopes.",
+        "scopesNote": "Optional. A scope listed here routes every package under it to this registry, so a scope that also holds publicly published packages stops resolving. Leave it empty when the repository commits its own .npmrc, or when single dependencies are pinned with a named-registry prefix such as gh: (pnpm 11.1 or newer) - the token authenticates the registry either way.",
         "token": "Access token",
         "save": "Add registry"
       },
@@ -5459,12 +5457,22 @@
     "inspector": {
       "runPlanning": "Run planning",
       "answerPlanning": "Answer planning questions",
+      "reviewPlan": "Review plan",
+      "resolveDecision": "Resolve",
       "planningInProgress": "Planning in progress",
       "pause": "Pause",
       "resume": "Resume",
       "cancel": "Cancel initiative",
       "hint": "The planning pipeline explores the codebase, drafts the multi-phase plan for approval, then commits the tracker document to the repository."
     },
+    "planReview": {
+      "title": "This plan is waiting for you",
+      "body": "The planner drafted the phases and items below. Approve them to commit the plan and start the work, or send the plan back with what to change.",
+      "approve": "Approve plan",
+      "requestChanges": "Request changes",
+      "feedbackPlaceholder": "What should the planner change? Scope, phase order, missing work, an item that belongs elsewhere…",
+      "sendBack": "Send back to the planner"
+    },
     "planning": {
       "title": "Plan the initiative",
       "subtitle": "Answer the planner's questions so it can scope the initiative",