@cat-factory/app 0.194.0 → 0.195.1

package/app/components/initiative/InitiativeTrackerWindow.vue

@@ -23,10 +23,12 @@ import {
   INITIATIVE_STATUS_LABEL_KEYS,
   initiativeProgress,
   pendingCheckpointPhase,
+  planReviewDocument,
 } from '~/utils/initiative'
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
 import StepRunMeta from '~/components/panels/StepRunMeta.vue'
 import InitiativePlanReview from '~/components/initiative/InitiativePlanReview.vue'
+import InitiativePlanNotice from '~/components/initiative/InitiativePlanNotice.vue'
 
 const board = useBoardStore()
 const initiatives = useInitiativesStore()
@@ -61,6 +63,24 @@ const {
   stepIndex: () => stepIndex.value,
 })
 
+/**
+ * The `StepRunMeta` prop bundle, or null when no step speaks for this window. Bound as one object
+ * because it has two homes — the tracker's end-side column, and the plan review's sidebar while the
+ * review owns the window — and the run details must read identically in both.
+ */
+const runMeta = computed(() =>
+  metaStep.value
+    ? {
+        step: metaStep.value,
+        instanceId: runId.value,
+        stepNumber: position.value,
+        totalSteps: totalSteps.value,
+        runFailed: runFailed.value,
+        failureAt: failureAt.value,
+      }
+    : null,
+)
+
 const phases = computed(() => initiative.value?.phases ?? [])
 function itemsOf(phaseId: string): InitiativeItem[] {
   return (initiative.value?.items ?? []).filter((i) => i.phaseId === phaseId)
@@ -103,9 +123,19 @@ async function checkpointControl(action: 'resume' | 'cancel') {
 // ---- Plan review: the planner step's human gate, resolved right here -----------------------
 // Derived from the BLOCK (via the shared planning composable), not from this window's own
 // `stepIndex`: the card / inspector open the tracker with no step, and that is the entry point a
-// human parked on the gate actually uses. So the rail appears on every route into the window.
+// human parked on the gate actually uses. So the review appears on every route into the window.
 const { planApproval } = useInitiativePlanning(() => blockId.value ?? '')
 
+/**
+ * The plan document the parked gate offers, or `''` — which is also the layout decision. A rendered
+ * plan is a REPLACEMENT for the tracker body rather than a card above it: the render reads the
+ * ingested entity, so the sections below would be a second copy of what the reviewer is reading,
+ * and everything the tracker adds on top (PR links, item curation, checkpoints, follow-ups) is
+ * execution-time state that cannot exist until the plan is committed. With no document, the tracker
+ * body IS the plan, so the gate takes the compact notice above it instead.
+ */
+const planDocument = computed(() => planReviewDocument(planApproval.value))
+
 const policyRules = computed(() => initiative.value?.policy?.rules ?? [])
 function ruleAxes(rule: { minComplexity?: number; minRisk?: number; minImpact?: number }): string {
   const axes = [
@@ -236,30 +266,54 @@ async function savePolicy() {
       </UBadge>
     </template>
 
-    <div class="flex min-h-0 flex-1">
+    <!-- The planner's human gate, with the plan rendered as a document. This window is where the
+         park ROUTES (the planner's archetype declares this result view), so it is the only surface
+         that can resolve it — and while it is parked the review OWNS the window: an outline sidebar,
+         the plan at full height, per-block commenting and the commands in an end-side rail, the same
+         tools and the same shape the step reader gives the architect's prose. The tracker body it
+         replaces would only repeat the plan (see `planDocument`). -->
+    <InitiativePlanReview
+      v-if="planApproval && planDocument"
+      :approval="planApproval.approval"
+      :instance-id="planApproval.instanceId"
+      :can-execute="access.canExecuteRuns.value"
+      :plan-document="planDocument"
+    >
+      <template v-if="runMeta" #run-details>
+        <StepRunMeta v-bind="runMeta" />
+      </template>
+    </InitiativePlanReview>
+
+    <div v-else class="flex min-h-0 flex-1">
       <div class="min-w-0 flex-1 overflow-y-auto px-5 py-4">
-        <!-- No entity yet (module unwired / still creating) -->
+        <!-- A parked gate whose step rendered no plan: the commands, plus a notice pointing at the
+             sections below — which in that case are the only rendering of the plan there is.
+             Deliberately OUTSIDE the entity branch: the gate lives on the RUN, so it is parked
+             before `initiatives.load()` has resolved (and stays parked if it fails), and a window
+             that answered such a gate with the empty state alone would leave it unresolvable from
+             the UI. `hasSections` is what keeps the notice honest about whether the sections it
+             points at are actually rendered underneath. -->
+        <InitiativePlanNotice
+          v-if="planApproval"
+          :approval="planApproval.approval"
+          :instance-id="planApproval.instanceId"
+          :can-execute="access.canExecuteRuns.value"
+          :has-sections="!!initiative"
+        />
+
+        <!-- No entity yet (module unwired / still creating). Centred in the column when it is the
+             only thing in it; merely inset when the notice above it means `h-full` would overflow
+             the scroller by the notice's own height. -->
         <div
           v-if="!initiative"
-          class="flex h-full flex-col items-center justify-center gap-2 text-center text-slate-400"
+          class="flex flex-col items-center justify-center gap-2 text-center text-slate-400"
+          :class="planApproval ? 'py-16' : 'h-full'"
         >
           <UIcon name="i-lucide-milestone" class="h-8 w-8 opacity-40" />
           <p class="text-sm">{{ t('initiative.tracker.empty') }}</p>
         </div>
 
         <template v-else>
-          <!-- The planner's human gate. This window is where the park ROUTES (the planner's
-               archetype declares this result view), so it is the only surface that can resolve
-               it — and the plan it judges is rendered as a navigable document with per-block
-               commenting, the same tools the step reader gives the architect's prose. -->
-          <InitiativePlanReview
-            v-if="planApproval"
-            :approval="planApproval.approval"
-            :instance-id="planApproval.instanceId"
-            :can-execute="access.canExecuteRuns.value"
-            :output-is-rendered="planApproval.outputIsRendered"
-          />
-
           <!-- Paused at a phase checkpoint (D2): a completed checkpoint phase is awaiting
                    review before the next phase spawns. Read the phase's artifacts/PRs below,
                    then resume (continue) or cancel (stop) the initiative right here. -->
@@ -646,18 +700,11 @@ async function savePolicy() {
            through `useResultViewRunMeta`, so it is present on the card / inspector entry point
            too — where this window carries no step index of its own. -->
       <aside
-        v-if="metaStep"
+        v-if="runMeta"
         data-testid="initiative-tracker-run-meta"
         class="hidden w-60 shrink-0 flex-col gap-4 overflow-y-auto border-s border-slate-800 bg-slate-900/50 px-4 py-4 lg:flex"
       >
-        <StepRunMeta
-          :step="metaStep"
-          :instance-id="runId"
-          :step-number="position"
-          :total-steps="totalSteps"
-          :run-failed="runFailed"
-          :failure-at="failureAt"
-        />
+        <StepRunMeta v-bind="runMeta" />
       </aside>
     </div>
   </ResultWindowShell>

package/app/components/pipeline/AgentPromptEditor.vue

@@ -3,6 +3,7 @@ import { computed, ref, watch } from 'vue'
 import type { AgentPromptRevision } from '~/types/agent-prompts'
 import { agentKindMeta } from '~/utils/catalog'
 import AgentKindIcon from '~/components/pipeline/AgentKindIcon.vue'
+import OutputBudgetInput from '~/components/pipeline/OutputBudgetInput.vue'
 import {
   draftForRevision,
   isDirty,
@@ -30,6 +31,7 @@ const emit = defineEmits<{ close: [] }>()
 const { t } = useI18n()
 const toast = useToast()
 const prompts = useAgentPromptsStore()
+const agentSettings = useAgentSettingsStore()
 
 const open = computed({
   get: () => props.agentKind !== null,
@@ -76,6 +78,29 @@ watch(
 const detail = computed(() => prompts.detail)
 const label = computed(() => (props.agentKind ? agentKindMeta(props.agentKind).label : ''))
 
+/**
+ * The workspace-wide output-token ceiling for this kind — the same per-agent-kind scope this
+ * editor already owns for the prompt, which is why it lives here rather than in a settings screen
+ * of its own. A pipeline step may still pin its own budget over it.
+ *
+ * Saved on its own, immediately: unlike the prompt (whose save appends a revision and wants an
+ * explicit commit) this is one scalar with no history, so a separate Save button would only invite
+ * someone to type a number, close the modal and wonder why nothing changed.
+ */
+const budget = computed(() =>
+  props.agentKind ? agentSettings.maxOutputTokensFor(props.agentKind) : undefined,
+)
+
+async function saveBudget(value: number | null) {
+  const kind = props.agentKind
+  if (!kind) return
+  try {
+    await agentSettings.setMaxOutputTokens(kind, value)
+  } catch {
+    toast.add({ title: t('agentPrompt.toast.budgetFailed'), color: 'error' })
+  }
+}
+
 /** The live prompt, so "no change" can be reported instead of appending an identical revision. */
 const dirty = computed(() => isDirty(draft.value, detail.value))
 /** Nothing to revert to when the workspace is already running the shipped prompt. */
@@ -164,6 +189,21 @@ function revisionLabel(revision: AgentPromptRevision): string {
           </UBadge>
         </div>
 
+        <!-- The workspace-wide output ceiling for this kind. Same per-agent-kind scope as the
+             prompt below it; saves on change, since there is no revision log to commit to. -->
+        <div class="flex flex-wrap items-center gap-2">
+          <span class="text-[11px] text-slate-400">{{ t('pipeline.outputBudget.kindLabel') }}</span>
+          <OutputBudgetInput
+            class="w-32"
+            :model-value="budget"
+            :disabled="agentSettings.saving"
+            @update:model-value="saveBudget"
+          />
+          <span class="text-[10px] text-slate-500">
+            {{ t('pipeline.outputBudget.kindHint') }}
+          </span>
+        </div>
+
         <!-- What the platform appends is SHOWN, not described. A prose summary of it is copy
              that silently goes stale the moment a directive is added, and a user who does not
              know what is already there writes a prompt that fights it. -->

package/app/components/pipeline/OutputBudgetInput.vue

@@ -0,0 +1,69 @@
+<script setup lang="ts">
+/**
+ * The output-token ceiling control, shared by both tiers that configure one: a pipeline step's
+ * own override (in the builder) and a workspace's per-agent-kind default (in the prompt editor).
+ *
+ * Empty means INHERIT, and that is the whole reason this is a component rather than a bare
+ * `UInput type="number"` at each call site: "no value" has to round-trip as `null` and never as
+ * `0`, or clearing the field would send a zero-token ceiling — every reply empty — instead of
+ * falling back to the next tier. The bounds come from the contract, so the input cannot offer a
+ * value the server would reject.
+ */
+import { computed } from 'vue'
+import { MAX_AGENT_MAX_OUTPUT_TOKENS, MIN_AGENT_MAX_OUTPUT_TOKENS } from '~/types/agent-settings'
+
+const props = defineProps<{
+  /** The configured ceiling, or null/undefined when this tier inherits. */
+  modelValue: number | null | undefined
+  /** What this tier falls back to, shown as the placeholder so "inherit" names a number. */
+  inheritedValue?: number | undefined
+  disabled?: boolean
+}>()
+
+const emit = defineEmits<{ 'update:modelValue': [number | null] }>()
+
+const { t, n } = useI18n()
+
+/** Bound to the input as a string so an empty field is distinguishable from a typed 0. */
+const text = computed(() => (props.modelValue != null ? String(props.modelValue) : ''))
+
+/**
+ * The placeholder names the inherited ceiling when the caller knows it, so a user reading an
+ * empty field learns what the step will actually run on rather than just that it is unset.
+ */
+const placeholder = computed(() =>
+  props.inheritedValue != null
+    ? t('pipeline.outputBudget.inheritsValue', { tokens: n(props.inheritedValue) })
+    : t('pipeline.outputBudget.inherits'),
+)
+
+/**
+ * Commit on change. An empty/unparseable field clears to `null` (inherit); anything else is
+ * clamped into the contract's range rather than rejected, so a fat-fingered extra digit lands on
+ * the ceiling instead of silently failing the save with a 422.
+ */
+function commit(raw: string | number) {
+  const trimmed = String(raw).trim()
+  if (trimmed === '') return emit('update:modelValue', null)
+  const parsed = Number.parseInt(trimmed, 10)
+  if (!Number.isFinite(parsed)) return emit('update:modelValue', null)
+  const clamped = Math.min(
+    MAX_AGENT_MAX_OUTPUT_TOKENS,
+    Math.max(MIN_AGENT_MAX_OUTPUT_TOKENS, parsed),
+  )
+  emit('update:modelValue', clamped)
+}
+</script>
+
+<template>
+  <UInput
+    :model-value="text"
+    type="number"
+    size="xs"
+    :min="MIN_AGENT_MAX_OUTPUT_TOKENS"
+    :max="MAX_AGENT_MAX_OUTPUT_TOKENS"
+    :placeholder="placeholder"
+    :disabled="disabled"
+    @change="commit(($event.target as HTMLInputElement).value)"
+  />
+</template>

package/app/components/pipeline/PipelineBuilder.vue

@@ -5,6 +5,7 @@ import type { AgentKind, Pipeline, PipelinePurpose } from '~/types/domain'
 import AgentPalette from '~/components/palettes/AgentPalette.vue'
 import AgentKindIcon from '~/components/pipeline/AgentKindIcon.vue'
 import AgentPromptEditor from '~/components/pipeline/AgentPromptEditor.vue'
+import OutputBudgetInput from '~/components/pipeline/OutputBudgetInput.vue'
 import { showOverrideField } from '~/utils/uiMode'
 import {
   agentKindMeta,
@@ -86,6 +87,7 @@ const agents = useAgentsStore()
 const ui = useUiStore()
 const uiMode = useUiModeStore()
 const agentPrompts = useAgentPromptsStore()
+const agentSettings = useAgentSettingsStore()
 
 // The agent kind whose system prompt is open in the editor (null = closed). Per-KIND, not
 // per-step: an override applies to every run of that agent in the workspace, so two steps of
@@ -102,6 +104,26 @@ const promptEditorKind = ref<AgentKind | null>(null)
 function showPromptEditor(kind: AgentKind): boolean {
   return showOverrideField(uiMode.isAdvanced, agentPrompts.isCustomized(kind) || null)
 }
+
+/**
+ * Whether this step's own output-budget field shows. Same override rule as the prompt editor: a
+ * step with no pinned ceiling inherits, so the control is advanced-only until a value actually
+ * exists — at which point it must be visible in BOTH tiers, or a basic-mode user runs on a budget
+ * a teammate pinned and they can neither see nor clear.
+ */
+function showOutputBudget(index: number): boolean {
+  return showOverrideField(uiMode.isAdvanced, pipelines.draftMaxOutputTokens(index) ?? null)
+}
+
+/**
+ * What a step with no pinned ceiling actually runs on: the workspace's per-kind setting when it
+ * has one. Shown as the field's placeholder. Undefined ⇒ the deployment default, which the SPA
+ * deliberately does NOT guess at — it is env-resolved per agent kind and a number invented here
+ * would be wrong on the deployments that tuned it.
+ */
+function inheritedOutputBudget(kind: AgentKind): number | undefined {
+  return agentSettings.maxOutputTokensFor(kind)
+}
 const releaseHealth = useReleaseHealthStore()
 const skills = useSkillsStore()
 
@@ -151,6 +173,9 @@ watch(open, (isOpen) => {
   // Best-effort: the builder is fully usable without it, and a deployment that wires no
   // override store answers 503 here.
   if (isOpen) agentPrompts.loadIndex().catch(() => {})
+  // The workspace's per-kind output ceilings, which the per-step field shows as its inherited
+  // placeholder and the prompt editor edits. Best-effort on the same terms as the prompt index.
+  if (isOpen) agentSettings.load().catch(() => {})
 })
 
 function add(kind: AgentKind) {
@@ -694,6 +719,23 @@ async function clone(p: Pipeline) {
                 </p>
               </div>
 
+              <!-- This step's own output-token ceiling. An OVERRIDE of the workspace's per-kind
+                 setting (itself an override of the deployment routing default), so it is
+                 advanced-only until a value is pinned; empty inherits. -->
+              <div v-if="showOutputBudget(unit.index)" class="ms-6 flex items-center gap-2">
+                <span class="text-[10px] text-slate-500">
+                  {{ t('pipeline.outputBudget.stepLabel') }}
+                </span>
+                <OutputBudgetInput
+                  class="w-28"
+                  :model-value="pipelines.draftMaxOutputTokens(unit.index)"
+                  :inherited-value="inheritedOutputBudget(unit.kind)"
+                  @update:model-value="
+                    pipelines.setDraftMaxOutputTokens(unit.index, $event ?? undefined)
+                  "
+                />
+              </div>
+
               <!-- Attached companion: a dependent reviewer for this producer, optionally
                  gated on the task estimate. -->
               <div

package/app/composables/api/agentSettings.ts

@@ -0,0 +1,32 @@
+import {
+  listWorkspaceAgentSettingsContract,
+  updateWorkspaceAgentSettingsContract,
+} from '@cat-factory/contracts'
+import type { UpdateWorkspaceAgentSettingsInput } from '~/types/agent-settings'
+import type { ApiContext } from './context'
+
+/**
+ * The workspace's per-agent-kind generation settings, edited from the pipeline builder. There is
+ * no delete route: clearing the last configured field IS the way back to the deployment default,
+ * and the server drops the row when nothing is left set.
+ */
+export function agentSettingsApi({ send, ws }: ApiContext) {
+  return {
+    // Every kind the workspace has configured — nothing for a kind that inherits.
+    listWorkspaceAgentSettings: (workspaceId: string) =>
+      send(listWorkspaceAgentSettingsContract, { pathPrefix: ws(workspaceId) }),
+
+    // Patch one kind. An explicit null clears the field; the response is null once the kind is
+    // back to inheriting entirely.
+    updateWorkspaceAgentSettings: (
+      workspaceId: string,
+      agentKind: string,
+      body: UpdateWorkspaceAgentSettingsInput,
+    ) =>
+      send(updateWorkspaceAgentSettingsContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { agentKind },
+        body,
+      }),
+  }
+}

package/app/composables/useApi.ts

@@ -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/stores/agentSettings.ts

@@ -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/outputBudget.spec.ts

@@ -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

@@ -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

@@ -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/utils/initiative.spec.ts

@@ -9,6 +9,7 @@ import {
   isPendingQuestion,
   orderInterviewQuestions,
   pendingCheckpointPhase,
+  planReviewDocument,
   selectPlanApproval,
 } from './initiative'
 
@@ -205,6 +206,48 @@ describe('selectPlanApproval', () => {
   })
 })
 
+// Which shape the plan gate takes in the tracker window: a document review that OWNS the window, or
+// the compact notice above the tracker's own sections. Both the window's layout and the review
+// surface read this one value, so these pin the cases where "there is a plan to read" is not the
+// same as "the proposal is non-empty".
+
+describe('planReviewDocument', () => {
+  const gate = (proposal: string | null | undefined, outputIsRendered: boolean) => ({
+    approval: { proposal },
+    outputIsRendered,
+  })
+
+  it('is the proposal when the step says it IS the plan rendering', () => {
+    expect(planReviewDocument(gate('# Initiative plan\n\n## Goal', true))).toBe(
+      '# Initiative plan\n\n## Goal',
+    )
+  })
+
+  it('returns the proposal verbatim, so comment anchors stay on the lines they quote', () => {
+    // Anchoring is by SOURCE LINE, so trimming a leading newline would shift every anchor up one.
+    expect(planReviewDocument(gate('\n# Initiative plan\n', true))).toBe('\n# Initiative plan\n')
+  })
+
+  it('reads an un-rendered proposal as no document, however substantial it looks', () => {
+    // The planner's transcript summary: a perfectly non-empty string that is not the plan. Showing
+    // it under a table of contents is the failure the rendered review exists to end.
+    expect(
+      planReviewDocument(gate('I drafted a three-phase plan and stopped for review.', false)),
+    ).toBe('')
+  })
+
+  it('reads a rendered but blank proposal as no document', () => {
+    expect(planReviewDocument(gate('   \n  ', true))).toBe('')
+    expect(planReviewDocument(gate(null, true))).toBe('')
+    expect(planReviewDocument(gate(undefined, true))).toBe('')
+  })
+
+  it('has no document when nothing is parked', () => {
+    expect(planReviewDocument(null)).toBe('')
+    expect(planReviewDocument(undefined)).toBe('')
+  })
+})
+
 /**
  * These tables are the reason the initiative card and the inspector word one park identically,
  * and they are exactly the shape both i18n drift guards are blind to: the typed-key check and