npm - @cat-factory/app - Versions diffs - 0.193.0 → 0.195.0 - Mend

@cat-factory/app 0.193.0 → 0.195.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

package/app/components/board/nodes/BlockNode.vue +28 -46
package/app/components/board/nodes/ModuleFrame.vue +4 -33
package/app/components/board/nodes/ResizeGrips.vue +130 -0
package/app/components/pipeline/AgentPromptEditor.vue +40 -0
package/app/components/pipeline/OutputBudgetInput.vue +69 -0
package/app/components/pipeline/PipelineBuilder.vue +42 -0
package/app/components/requirements/RequirementsReviewWindow.vue +34 -0
package/app/composables/api/agentSettings.ts +32 -0
package/app/composables/api/board.ts +7 -1
package/app/composables/api/context.ts +2 -0
package/app/composables/useApi.ts +2 -0
package/app/composables/useFrameResize.ts +116 -22
package/app/stores/agentSettings.ts +86 -0
package/app/stores/board/placement.ts +64 -1
package/app/stores/board.spec.ts +51 -0
package/app/stores/outputBudget.spec.ts +55 -0
package/app/stores/pipelines/draftStepConfig.ts +23 -0
package/app/types/agent-settings.ts +12 -0
package/app/types/requirements.ts +1 -0
package/i18n/locales/de.json +16 -2
package/i18n/locales/en.json +20 -2
package/i18n/locales/es.json +16 -2
package/i18n/locales/fr.json +16 -2
package/i18n/locales/he.json +16 -2
package/i18n/locales/it.json +16 -2
package/i18n/locales/ja.json +16 -2
package/i18n/locales/pl.json +16 -2
package/i18n/locales/tr.json +16 -2
package/i18n/locales/uk.json +16 -2
package/package.json +2 -2

package/app/composables/useApi.ts CHANGED Viewed

@@ -3,6 +3,7 @@ import { createApiClient, createSend, createSendWith } from './api/client'
 import type { ApiContext } from './api/context'
 import { accountsApi } from './api/accounts'
 import { agentPromptsApi } from './api/agentPrompts'
+import { agentSettingsApi } from './api/agentSettings'
 import { platformObservabilityApi } from './api/platformObservability'
 import { reportsApi } from './api/reports'
 import { authApi } from './api/auth'
@@ -136,6 +137,7 @@ export function useApi() {
     ...notificationsApi(ctx),
     ...presetsApi(ctx),
     ...agentPromptsApi(ctx),
+    ...agentSettingsApi(ctx),
     ...preflightsApi(ctx),
     ...publicApiKeysApi(ctx),
     ...sharedStacksApi(ctx),

package/app/composables/useFrameResize.ts CHANGED Viewed

@@ -2,56 +2,150 @@ import { ref } from 'vue'
 import type { Block } from '~/types/domain'
 /**
- * Pointer-driven resizing for service frames (Miro-style border drag). The drag
- * delta is divided by the board zoom so the edge tracks the cursor, and the new
- * size is clamped to the frame's content extent so dragging in never clips the
- * tasks/modules inside. The frame grows live (the store block is mutated in place,
- * which `containerSize` reads back), and the final size is persisted once on
- * release rather than on every move.
+ * The eight border/corner grips, each as the pair of unit factors saying how far the drag moves
+ * the container's ORIGIN versus its far edge. `1` on an origin axis means that axis's border is
+ * the one being dragged (west/north), so the box grows the OPPOSITE way from the pointer delta.
+ *
+ * Encoding the geometry as data rather than a `switch` per axis is what keeps the corners honest:
+ * `nw` is exactly `n` and `w` applied together, and there is no eighth case to forget.
+ */
+const HANDLES = {
+  n: { ox: 0, oy: 1, sx: 0, sy: -1, cursor: 'ns-resize' },
+  s: { ox: 0, oy: 0, sx: 0, sy: 1, cursor: 'ns-resize' },
+  e: { ox: 0, oy: 0, sx: 1, sy: 0, cursor: 'ew-resize' },
+  w: { ox: 1, oy: 0, sx: -1, sy: 0, cursor: 'ew-resize' },
+  ne: { ox: 0, oy: 1, sx: 1, sy: -1, cursor: 'nesw-resize' },
+  nw: { ox: 1, oy: 1, sx: -1, sy: -1, cursor: 'nwse-resize' },
+  se: { ox: 0, oy: 0, sx: 1, sy: 1, cursor: 'nwse-resize' },
+  sw: { ox: 1, oy: 0, sx: -1, sy: 1, cursor: 'nesw-resize' },
+} as const
+export type ResizeEdge = keyof typeof HANDLES
+/** The grips in render order, so a component can `v-for` them instead of listing eight blocks. */
+export const RESIZE_EDGES = Object.keys(HANDLES) as ResizeEdge[]
+/** The `cursor` a given grip shows, and holds on `<body>` while its drag runs. */
+export function resizeCursor(edge: ResizeEdge): string {
+  return HANDLES[edge].cursor
+}
+/**
+ * Pointer-driven resizing for containers (service frames and modules) by dragging any border or
+ * corner, Miro-style. The drag delta is divided by the board zoom so the border tracks the
+ * cursor, and the new size is clamped to the container's content extent so dragging inwards never
+ * clips the tasks/modules inside.
+ *
+ * Dragging the north or west border also moves the container's ORIGIN, and a child's position is
+ * stored relative to that origin — so the store translates the children by the inverse (see
+ * `previewResize`) and the backend does the same on commit, which is what makes the border extend
+ * past the contents instead of dragging them along. The origin is derived from the CLAMPED size
+ * rather than from the raw pointer delta: once the box has hit its content floor the border must
+ * stop dead, and a separately-clamped origin would keep sliding, walking the whole container
+ * across the board.
+ *
+ * The container grows live off the store's optimistic geometry, and the final bounds are
+ * persisted ONCE on release rather than on every move.
  */
 export function useFrameResize() {
   const board = useBoardStore()
   const ui = useUiStore()
   const access = useWorkspaceAccess()
-  /** Id of the frame currently being resized, for cursor/handle styling. */
+  /** Id of the container currently being resized, for cursor/grip styling. */
   const resizingId = ref<string | null>(null)
   /**
-   * Begin a resize from one of the frame's edges/corner. `edge` selects which
-   * dimensions move: `'e'` width only, `'s'` height only, `'se'` both.
+   * How far the origin may travel INWARD before the nearest child would land at a negative
+   * offset — i.e. outside the box, spilling over the very border being dragged. `contentSize` is
+   * no help here: it measures only the FAR edge of the contents, which a north/west shrink moves
+   * inward in step with the border, so nothing there ever objects. `Infinity` for an empty
+   * container, which is then bounded by `contentSize`'s empty floor alone.
    */
-  function startResize(block: Block, e: PointerEvent, edge: 'e' | 's' | 'se') {
+  function originSlack(id: string): { x: number; y: number } {
+    const children = board.childrenOf(id)
+    if (!children.length) return { x: Number.POSITIVE_INFINITY, y: Number.POSITIVE_INFINITY }
+    return {
+      x: Math.min(...children.map((c) => c.position.x)),
+      y: Math.min(...children.map((c) => c.position.y)),
+    }
+  }
+  /** Begin a resize from one of the container's borders or corners. */
+  function startResize(block: Block, e: PointerEvent, edge: ResizeEdge) {
     if (e.button !== 0) return
-    // Resizing a frame persists its size — a `board.write` mutation, so a read-only
-    // viewer's resize no-ops (the grips are hidden for them at the component level).
+    // Resizing persists geometry — a `board.write` mutation, so a read-only viewer's resize
+    // no-ops (the grips are hidden for them at the component level).
     if (!access.canWriteBoard.value) return
     e.preventDefault()
     e.stopPropagation()
+    const handle = HANDLES[edge]
     const startX = e.clientX
     const startY = e.clientY
-    // The content extent is the floor — never shrink a frame below its tasks.
-    const min = board.contentSize(block.id)
-    // Seed from the current rendered size so the first move doesn't jump.
+    // Seed from the current rendered geometry so the first move doesn't jump. `size` may be
+    // absent (an auto-sized container), which is also what a rejected resize must restore.
     const start = board.containerSize(block.id)
+    const from = {
+      position: { ...block.position },
+      size: block.size ? { ...block.size } : undefined,
+    }
+    // The floors, snapshotted once: on an origin-axis drag the children MOVE, so a floor re-read
+    // mid-drag would chase them. `contentSize` bounds the far edge; the near-edge bound applies
+    // only where the origin travels, and only inwards.
+    const min = board.contentSize(block.id)
+    const slack = originSlack(block.id)
+    const floor = {
+      w: handle.ox ? Math.max(min.w, start.w - slack.x) : min.w,
+      h: handle.oy ? Math.max(min.h, start.h - slack.y) : min.h,
+    }
     resizingId.value = block.id
+    // Hold the resize cursor on `<body>` (and kill text selection) for the whole drag: the
+    // pointer routinely outruns the 12px grip, and without this the cursor flips back to the
+    // default mid-drag, which reads as "the grab was dropped" even though the border is still
+    // tracking.
+    const body = document.body
+    const priorCursor = body.style.cursor
+    const priorUserSelect = body.style.userSelect
+    body.style.cursor = handle.cursor
+    body.style.userSelect = 'none'
+    let bounds = { position: from.position, size: start }
+    let moved = false
     const onMove = (ev: PointerEvent) => {
       const z = ui.zoom || 1
-      const w = edge === 's' ? start.w : Math.max(min.w, start.w + (ev.clientX - startX) / z)
-      const h = edge === 'e' ? start.h : Math.max(min.h, start.h + (ev.clientY - startY) / z)
-      // Optimistic, local-only: mutate the cached block so the frame grows live
-      // without a round-trip on every pointer move.
-      block.size = { w: Math.round(w), h: Math.round(h) }
+      const dx = (ev.clientX - startX) / z
+      const dy = (ev.clientY - startY) / z
+      const w = Math.round(Math.max(floor.w, start.w + handle.sx * dx))
+      const h = Math.round(Math.max(floor.h, start.h + handle.sy * dy))
+      // A grown box on an origin axis extends BACKWARDS from where the far edge stays put, so
+      // the origin moves by whatever the size actually gained after clamping.
+      bounds = {
+        position: {
+          x: from.position.x - handle.ox * (w - start.w),
+          y: from.position.y - handle.oy * (h - start.h),
+        },
+        size: { w, h },
+      }
+      moved = true
+      // Optimistic, local-only (the store also translates the children): no round-trip per move.
+      board.previewResize(block.id, bounds.position, bounds.size)
     }
     const onUp = () => {
       window.removeEventListener('pointermove', onMove)
       window.removeEventListener('pointerup', onUp)
+      window.removeEventListener('pointercancel', onUp)
+      body.style.cursor = priorCursor
+      body.style.userSelect = priorUserSelect
       resizingId.value = null
-      // Persist the final size once (also re-applies it as the authoritative block).
-      if (block.size) void board.updateBlock(block.id, { size: block.size })
+      // A press with no movement is not a resize: committing it would emit a coarse board signal
+      // (every other client re-hydrates) to store the geometry it already had.
+      if (moved) void board.resizeBlock(block.id, bounds, from)
     }
     window.addEventListener('pointermove', onMove)
     window.addEventListener('pointerup', onUp)
+    // A cancelled pointer (touch interrupted by a gesture, window losing the pointer) never fires
+    // `pointerup`, so without this the body cursor stays stuck on `ew-resize` for the session.
+    window.addEventListener('pointercancel', onUp)
   }
   return { resizingId, startResize }

package/app/stores/agentSettings.ts ADDED Viewed

@@ -0,0 +1,86 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { WorkspaceAgentSettings } from '~/types/agent-settings'
+import { useWorkspaceStore } from '~/stores/workspace'
+/**
+ * The workspace's per-agent-kind generation settings — the pipeline builder's output-budget
+ * control, sitting beside the prompt editor.
+ *
+ * Unlike the prompt store there is only ONE shape to load: the whole configured set is a handful
+ * of small rows (a kind that inherits has no row at all), so the index IS the detail and the
+ * builder can badge every step and populate its editor from one request. There is nothing here
+ * worth deferring the way a prompt body is.
+ */
+export const useAgentSettingsStore = defineStore('agentSettings', () => {
+  const api = useApi()
+  const settings = ref<WorkspaceAgentSettings[]>([])
+  const loading = ref(false)
+  const saving = ref(false)
+  /** Configured ceilings by agent kind, for O(1) lookup while rendering a pipeline's steps. */
+  const ceilingByKind = computed(() => {
+    const out = new Map<string, number>()
+    for (const row of settings.value) {
+      if (row.maxOutputTokens != null) out.set(row.agentKind, row.maxOutputTokens)
+    }
+    return out
+  })
+  /** This kind's configured ceiling, or undefined when it inherits the deployment default. */
+  function maxOutputTokensFor(agentKind: string): number | undefined {
+    return ceilingByKind.value.get(agentKind)
+  }
+  /**
+   * Load the configured set. Best-effort like the prompt index: the builder is fully usable
+   * without it (every kind simply runs the deployment ceiling), and the endpoint 503s on a
+   * deployment that wires no settings store at all.
+   */
+  async function load() {
+    const ws = useWorkspaceStore()
+    if (!ws.workspaceId) return
+    loading.value = true
+    try {
+      settings.value = await api.listWorkspaceAgentSettings(ws.requireId())
+    } finally {
+      loading.value = false
+    }
+  }
+  /**
+   * Set (or clear, with `null`) one kind's output-token ceiling.
+   *
+   * Reconciles from the row the SERVER returned rather than the value sent: it answers `null`
+   * once the kind is back to inheriting, which is the same signal the row should disappear —
+   * so a clear and a set both land through one code path and the store can never keep a row the
+   * server has dropped.
+   */
+  async function setMaxOutputTokens(agentKind: string, maxOutputTokens: number | null) {
+    const ws = useWorkspaceStore()
+    saving.value = true
+    try {
+      const updated = await api.updateWorkspaceAgentSettings(ws.requireId(), agentKind, {
+        maxOutputTokens,
+      })
+      const rest = settings.value.filter((s) => s.agentKind !== agentKind)
+      settings.value = updated
+        ? [...rest, updated].sort((a, b) => a.agentKind.localeCompare(b.agentKind))
+        : rest
+      return updated
+    } finally {
+      saving.value = false
+    }
+  }
+  return {
+    settings,
+    loading,
+    saving,
+    ceilingByKind,
+    maxOutputTokensFor,
+    load,
+    setMaxOutputTokens,
+  }
+})

package/app/stores/board/placement.ts CHANGED Viewed

@@ -12,7 +12,7 @@ import { UNDO_WINDOW_MS } from './context'
  * in-closure functions, and the split is purely to keep every function within the size budget.
  */
 export function createBoardPlacement(ctx: BoardWriteContext) {
-  const { getBlock, upsert, api, toast, tr } = ctx
+  const { blocks, getBlock, upsert, api, toast, tr } = ctx
   /**
    * Move a block into a new container at a new local position. Drag-reparent commits
@@ -120,6 +120,67 @@ export function createBoardPlacement(ctx: BoardWriteContext) {
     }
   }
+  /**
+   * Translate every DIRECT child of a container — the client half of the compensation the
+   * backend's `shiftChildPositions` applies. A child's position is relative to its container's
+   * content origin, so moving that origin (a north/west border drag) has to move the children
+   * the other way or the contents slide with the border. Grandchildren ride their module.
+   */
+  function shiftChildren(parentId: string, dx: number, dy: number) {
+    if (!dx && !dy) return
+    for (const child of blocks.value) {
+      if (child.parentId !== parentId) continue
+      child.position = { x: child.position.x + dx, y: child.position.y + dy }
+    }
+  }
+  /**
+   * Local-only geometry update during an active border drag — the resize counterpart of
+   * {@link previewMove}, and for the same reason: persisting every pointer move would let an
+   * out-of-order response land a stale size after the user let go. Takes ABSOLUTE bounds and
+   * derives the origin delta itself, so a caller can drive it from a running drag without
+   * tracking what it has already applied. {@link resizeBlock} commits the final bounds once.
+   */
+  function previewResize(
+    id: string,
+    position: { x: number; y: number },
+    size?: { w: number; h: number },
+  ) {
+    const b = getBlock(id)
+    if (!b) return
+    shiftChildren(id, b.position.x - position.x, b.position.y - position.y)
+    b.position = position
+    b.size = size
+  }
+  /**
+   * Commit a border-drag resize: ONE call carrying both halves of the geometry, because only an
+   * operation that sees the origin delta can translate the container's children with it (see
+   * `BoardService.resizeBlock`). `from` is the pre-drag geometry — a rejected resize replays it
+   * through {@link previewResize}, which undoes the child translation by the same arithmetic that
+   * applied it, so a failure can't leave the contents offset from a box the server never stored.
+   */
+  async function resizeBlock(
+    id: string,
+    bounds: { position: { x: number; y: number }; size: { w: number; h: number } },
+    from: { position: { x: number; y: number }; size?: { w: number; h: number } },
+  ) {
+    const b = getBlock(id)
+    if (!b) return
+    previewResize(id, bounds.position, bounds.size)
+    try {
+      upsert(await api.resizeBlock(useWorkspaceStore().requireId(), id, bounds))
+    } catch (e) {
+      previewResize(id, from.position, from.size)
+      toast.add({
+        title: tr('board.toast.resizeFailed'),
+        description: e instanceof Error ? e.message : String(e),
+        icon: 'i-lucide-triangle-alert',
+        color: 'error',
+      })
+    }
+  }
   /** Patch the user-editable fields of a block (title, features, threshold…). */
   async function updateBlock(id: string, patch: UpdateBlockInput) {
     const b = getBlock(id)
@@ -196,6 +257,8 @@ export function createBoardPlacement(ctx: BoardWriteContext) {
     reparentBlock,
     previewMove,
     moveBlock,
+    previewResize,
+    resizeBlock,
     updateBlock,
     toggleDependency,
     removeDependency,

package/app/stores/board.spec.ts CHANGED Viewed

@@ -310,6 +310,57 @@ describe('board store optimistic rollback', () => {
     expect(store.getBlock('t1')?.description).toBe('keep')
   })
+  it('previewResize translates the children when the drag moves the content origin', () => {
+    // A child's position is relative to its container's content origin, so growing the frame
+    // 40px west (origin -40) has to move every direct child +40 or the whole content slides with
+    // the border. A grandchild rides its module and must NOT move on its own.
+    const store = useBoardStore()
+    store.hydrate([
+      frame('f1', { position: { x: 100, y: 100 }, size: { w: 600, h: 400 } }),
+      moduleBlock('m1', 'f1', { position: { x: 20, y: 30 } }),
+      task('t1', 'f1', { position: { x: 10, y: 20 } }),
+      task('t2', 'm1', { position: { x: 5, y: 5 } }),
+    ])
+    store.previewResize('f1', { x: 60, y: 100 }, { w: 640, h: 400 })
+    expect(store.getBlock('t1')?.position).toEqual({ x: 50, y: 20 })
+    expect(store.getBlock('m1')?.position).toEqual({ x: 60, y: 30 })
+    expect(store.getBlock('t2')?.position).toEqual({ x: 5, y: 5 })
+  })
+  it('previewResize leaves the children alone when only the far border moved', () => {
+    const store = useBoardStore()
+    store.hydrate([
+      frame('f1', { position: { x: 100, y: 100 }, size: { w: 600, h: 400 } }),
+      task('t1', 'f1', { position: { x: 10, y: 20 } }),
+    ])
+    store.previewResize('f1', { x: 100, y: 100 }, { w: 700, h: 500 })
+    expect(store.getBlock('t1')?.position).toEqual({ x: 10, y: 20 })
+    expect(store.getBlock('f1')?.size).toEqual({ w: 700, h: 500 })
+  })
+  it('resizeBlock rolls the bounds AND the child translation back when the API rejects', async () => {
+    // The rollback has to undo both halves: a restored box with its contents still offset is the
+    // one failure mode that looks fine until the next refresh moves everything.
+    vi.stubGlobal('useApi', () => ({
+      resizeBlock: () => Promise.reject(new Error('conflict')),
+    }))
+    setActivePinia(createPinia())
+    useWorkspaceStore().workspaceId = 'ws1'
+    const store = useBoardStore()
+    store.hydrate([
+      frame('f1', { position: { x: 100, y: 100 }, size: { w: 600, h: 400 } }),
+      task('t1', 'f1', { position: { x: 10, y: 20 } }),
+    ])
+    await store.resizeBlock(
+      'f1',
+      { position: { x: 60, y: 70 }, size: { w: 640, h: 430 } },
+      { position: { x: 100, y: 100 }, size: { w: 600, h: 400 } },
+    )
+    expect(store.getBlock('f1')?.position).toEqual({ x: 100, y: 100 })
+    expect(store.getBlock('f1')?.size).toEqual({ w: 600, h: 400 })
+    expect(store.getBlock('t1')?.position).toEqual({ x: 10, y: 20 })
+  })
   it('reparentBlock offers an undo that moves the block back to its previous home', async () => {
     vi.stubGlobal('useApi', () => ({
       reparentBlock: async (

package/app/stores/outputBudget.spec.ts ADDED Viewed

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest'
+import { usePipelinesStore } from '~/stores/pipelines'
+/**
+ * The per-step output-token ceiling rides the shared `StepOptions` bag, so its helpers owe the
+ * same normalization every other field in there follows: merge rather than clobber, and drop the
+ * whole entry once the bag empties. That last part is what keeps an all-default pipeline from
+ * persisting a `step_options` array of empty objects.
+ */
+describe('pipelines store — per-step output budget', () => {
+  it('sets, reads and clears a draft step’s ceiling', () => {
+    const pipelines = usePipelinesStore()
+    pipelines.addToDraft('doc-researcher')
+    expect(pipelines.draftMaxOutputTokens(0)).toBeUndefined()
+    pipelines.setDraftMaxOutputTokens(0, 24_000)
+    expect(pipelines.draftMaxOutputTokens(0)).toBe(24_000)
+    expect(pipelines.draftStepOptions[0]).toEqual({ maxOutputTokens: 24_000 })
+    // Clearing drops the field and, with the bag now empty, normalizes the entry back to null —
+    // so a step back on the inherited budget persists no options at all.
+    pipelines.setDraftMaxOutputTokens(0, undefined)
+    expect(pipelines.draftMaxOutputTokens(0)).toBeUndefined()
+    expect(pipelines.draftStepOptions[0]).toBeNull()
+  })
+  it('merges with the other options on the step rather than clobbering the bag', () => {
+    const pipelines = usePipelinesStore()
+    pipelines.addToDraft('requirements-review')
+    pipelines.toggleDraftAutoRecommend(0)
+    expect(pipelines.draftStepOptions[0]).toEqual({ autoRecommend: false })
+    pipelines.setDraftMaxOutputTokens(0, 12_000)
+    expect(pipelines.draftStepOptions[0]).toEqual({
+      autoRecommend: false,
+      maxOutputTokens: 12_000,
+    })
+    // And clearing one field leaves the other standing (the entry stays, since the bag is not empty).
+    pipelines.setDraftMaxOutputTokens(0, undefined)
+    expect(pipelines.draftStepOptions[0]).toEqual({ autoRecommend: false })
+  })
+  it('keeps each step’s ceiling independent', () => {
+    const pipelines = usePipelinesStore()
+    pipelines.addToDraft('doc-researcher')
+    pipelines.addToDraft('doc-outliner')
+    pipelines.setDraftMaxOutputTokens(0, 24_000)
+    pipelines.setDraftMaxOutputTokens(1, 10_000)
+    expect(pipelines.draftMaxOutputTokens(0)).toBe(24_000)
+    expect(pipelines.draftMaxOutputTokens(1)).toBe(10_000)
+  })
+})

package/app/stores/pipelines/draftStepConfig.ts CHANGED Viewed

@@ -139,6 +139,27 @@ export function createPipelineStepConfigActions(ctx: PipelinesContext) {
     draftStepOptions.value[index] = Object.keys(next).length ? next : null
   }
+  /**
+   * The output-token ceiling pinned on the draft step at `index`, or undefined when the step
+   * inherits (the workspace's per-kind setting, else the deployment default).
+   */
+  function draftMaxOutputTokens(index: number): number | undefined {
+    return draftStepOptions.value[index]?.maxOutputTokens
+  }
+  /**
+   * Set (or clear) this step's own output-token ceiling. Merges into the step's `StepOptions`
+   * bag rather than clobbering it; clearing drops the field and, if the bag empties, the whole
+   * entry — so a step back on the inherited budget persists no options at all, exactly like the
+   * other fields here.
+   */
+  function setDraftMaxOutputTokens(index: number, maxOutputTokens: number | undefined) {
+    const next: StepOptions = { ...draftStepOptions.value[index] }
+    if (maxOutputTokens != null) next.maxOutputTokens = maxOutputTokens
+    else delete next.maxOutputTokens
+    draftStepOptions.value[index] = Object.keys(next).length ? next : null
+  }
   return {
     toggleDraftGating,
     toggleDraftConsensus,
@@ -153,5 +174,7 @@ export function createPipelineStepConfigActions(ctx: PipelinesContext) {
     toggleDraftAutoRecommend,
     draftSkillId,
     setDraftSkillId,
+    draftMaxOutputTokens,
+    setDraftMaxOutputTokens,
   }
 }

package/app/types/agent-settings.ts ADDED Viewed

@@ -0,0 +1,12 @@
+// Per-workspace, per-agent-kind generation settings, mirroring `@cat-factory/contracts`
+// (agent-settings.ts). Today one knob: the output-token ceiling a kind's inline calls run under.
+// A kind absent from the store inherits the deployment routing default, and a pipeline step's own
+// `stepOptions.maxOutputTokens` still overrides whatever is set here.
+//
+// All wire shapes are sourced from @cat-factory/contracts (single source of truth).
+export type {
+  UpdateWorkspaceAgentSettingsInput,
+  WorkspaceAgentSettings,
+} from '@cat-factory/contracts'
+export { MAX_AGENT_MAX_OUTPUT_TOKENS, MIN_AGENT_MAX_OUTPUT_TOKENS } from '@cat-factory/contracts'

package/app/types/requirements.ts CHANGED Viewed

@@ -15,6 +15,7 @@ export type {
   RequirementReviewItem,
   RequirementReviewStatus,
   ResolveRequirementsExceededChoice,
+  RecommendationSource,
   RecommendationStatus,
   RequirementRecommendation,
   RequirementReview,

package/i18n/locales/de.json CHANGED Viewed

@@ -2313,6 +2313,7 @@
       "updateFailed": "Änderungen konnten nicht gespeichert werden",
       "epicFailed": "Epic konnte nicht geändert werden",
       "moveFailed": "Verschieben nicht möglich",
+      "resizeFailed": "Größe konnte nicht geändert werden",
       "deleteFailed": "Löschen nicht möglich",
       "linkFailed": "Aufgaben konnten nicht verknüpft werden",
       "unlinkFailed": "Abhängigkeit konnte nicht entfernt werden",
@@ -2566,7 +2567,6 @@
       "mergedOfTotal": "{merged}/{total} gemergt",
       "noTasksYet": "Noch keine Aufgaben",
       "prCount": "{count} PR",
-      "implemented": "{merged}/{total} implementiert",
       "prReadyCount": "{count} PR bereit",
       "taskCount": "{count} Aufgabe | {count} Aufgaben",
       "moduleCount": "{count} Modul | {count} Module",
@@ -3750,6 +3750,13 @@
         "deleteFailed": "Pipeline konnte nicht gelöscht werden",
         "removeFailed": "Pipeline konnte nicht entfernt werden"
       }
+    },
+    "outputBudget": {
+      "stepLabel": "Ausgabebudget",
+      "kindLabel": "Ausgabebudget",
+      "kindHint": "Gilt für jeden Lauf dieses Agenten. Ein Pipeline-Schritt kann es überschreiben.",
+      "inherits": "Übernommen",
+      "inheritsValue": "Übernommen ({tokens})"
     }
   },
   "agentPrompt": {
@@ -3784,7 +3791,8 @@
       "reverted": "Zurück zum Standardprompt",
       "saveFailed": "Prompt konnte nicht gespeichert werden",
       "loadFailed": "Prompt konnte nicht geladen werden",
-      "conflict": "Jemand anderes hat diesen Prompt geändert. Neu geladen - wenden Sie Ihre Änderung erneut an."
+      "conflict": "Jemand anderes hat diesen Prompt geändert. Neu geladen - wenden Sie Ihre Änderung erneut an.",
+      "budgetFailed": "Ausgabebudget konnte nicht gespeichert werden"
     }
   },
   "agentTier": {
@@ -3864,6 +3872,12 @@
     "recommendationProgress": "{ready} / {total} bereit",
     "generatingSuggestion": "Ein fundierter Vorschlag wird generiert…",
     "currentStandard": "Aktueller Standard: {title}",
+    "grounding": {
+      "standard": "Team-Standard",
+      "project-spec": "Projektspezifikation",
+      "web": "Webquelle",
+      "general-practice": "Allgemeine Praxis"
+    },
     "accept": "Annehmen",
     "reject": "Ablehnen",
     "reRequestPlaceholder": "Nach einer anderen Empfehlung fragen…",

package/i18n/locales/en.json CHANGED Viewed

@@ -152,6 +152,7 @@
       "updateFailed": "Could not save changes",
       "epicFailed": "Could not change epic",
       "moveFailed": "Could not move",
+      "resizeFailed": "Could not resize",
       "deleteFailed": "Could not delete",
       "linkFailed": "Could not link tasks",
       "unlinkFailed": "Could not remove dependency",
@@ -417,7 +418,6 @@
       "mergedOfTotal": "{merged}/{total} merged",
       "noTasksYet": "No tasks yet",
       "prCount": "{count} PR",
-      "implemented": "{merged}/{total} implemented",
       "prReadyCount": "{count} PR ready",
       "taskCount": "{count} task | {count} tasks",
       "@taskCount": {
@@ -4188,6 +4188,13 @@
         "deleteFailed": "Could not delete pipeline",
         "removeFailed": "Could not remove pipeline"
       }
+    },
+    "outputBudget": {
+      "stepLabel": "Output budget",
+      "kindLabel": "Output budget",
+      "kindHint": "Applies to every run of this agent. A pipeline step can override it.",
+      "inherits": "Inherited",
+      "inheritsValue": "Inherited ({tokens})"
     }
   },
   "agentPrompt": {
@@ -4231,7 +4238,8 @@
       "reverted": "Back to the built-in prompt",
       "saveFailed": "Couldn't save the prompt",
       "loadFailed": "Couldn't load the prompt",
-      "conflict": "Someone else changed this prompt. Reloaded - re-apply your edit."
+      "conflict": "Someone else changed this prompt. Reloaded - re-apply your edit.",
+      "budgetFailed": "Could not save the output budget"
     }
   },
   "agentTier": {
@@ -4484,6 +4492,16 @@
     "recommendationProgress": "{ready} / {total} ready",
     "generatingSuggestion": "Generating a grounded suggestion…",
     "currentStandard": "Current standard: {title}",
+    "grounding": {
+      "standard": "Team standard",
+      "@standard": "Badge on a suggested answer: it came from the team's own best-practice standard. Noun phrase, short — fits a small badge.",
+      "project-spec": "Project spec",
+      "@project-spec": "Badge on a suggested answer: it came from the project's own committed specification documents. Noun phrase, short.",
+      "web": "Web source",
+      "@web": "Badge on a suggested answer: it came from a web search result. Noun phrase, short.",
+      "general-practice": "General practice",
+      "@general-practice": "Badge on a suggested answer: it rests only on the model's general knowledge, with no team standard, project spec or source behind it — the weakest grounding, so the wording should not sound authoritative. Noun phrase, short."
+    },
     "accept": "Accept",
     "reject": "Reject",
     "reRequestPlaceholder": "Ask for a different recommendation…",