@cat-factory/app 0.183.0 → 0.184.0

package/app/components/pipeline/AgentPromptEditor.logic.spec.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest'
+import type { AgentPromptDetail, AgentPromptRevision } from '~/types/agent-prompts'
+import {
+  draftForRevision,
+  isDirty,
+  isRevisionConflict,
+  saveIntent,
+} from './AgentPromptEditor.logic'
+
+const BUILTIN = 'You are a careful engineer.'
+
+function rev(overrides: Partial<AgentPromptRevision> = {}): AgentPromptRevision {
+  return { agentKind: 'coder', revision: 1, text: 'v1 text', createdAt: 1, ...overrides }
+}
+
+function detail(overrides: Partial<AgentPromptDetail> = {}): AgentPromptDetail {
+  return {
+    agentKind: 'coder',
+    builtinText: BUILTIN,
+    appendedText: '',
+    effectiveText: BUILTIN,
+    customized: false,
+    revisions: [],
+    ...overrides,
+  }
+}
+
+describe('saveIntent', () => {
+  it('sends the typed text as an override', () => {
+    expect(saveIntent('Be terse.', detail(), undefined)).toEqual({ text: 'Be terse.' })
+  })
+
+  it('sends null when the draft is the built-in, so the workspace keeps tracking it', () => {
+    // Storing a copy of the built-in would pin the workspace to today's wording — the exact
+    // thing the null revision exists to avoid.
+    expect(saveIntent(`  ${BUILTIN}  `, detail(), undefined)).toEqual({ text: null })
+  })
+
+  it('keeps restoredFrom while the draft still is that revision', () => {
+    const d = detail({ revisions: [rev({ revision: 3, text: 'v3 text' })] })
+    expect(saveIntent('v3 text', d, 3)).toEqual({ text: 'v3 text', restoredFrom: 3 })
+  })
+
+  it('DROPS restoredFrom once the draft has been edited away from that revision', () => {
+    // The regression this exists for: restore v3, tweak a line, save — and the log claims the
+    // new entry is v3 restored, so anyone tracing "what were we running" is misled by a record
+    // that reads as authoritative. Nothing errors; it is only wrong.
+    const d = detail({ revisions: [rev({ revision: 3, text: 'v3 text' })] })
+    expect(saveIntent('v3 text plus my edit', d, 3)).toEqual({ text: 'v3 text plus my edit' })
+  })
+
+  it('drops a restoredFrom naming a revision the (reloaded) log no longer has', () => {
+    // After a 409 the store holds the SERVER's log. A stale pick from before that reload must
+    // not be sent — the server would refuse it as `unknown_revision` and lose the user's text.
+    expect(saveIntent('anything', detail({ revisions: [rev({ revision: 1 })] }), 9)).toEqual({
+      text: 'anything',
+    })
+  })
+
+  it('keeps restoredFrom when restoring a revert revision, and still sends null', () => {
+    const d = detail({ revisions: [rev({ revision: 2, text: null })] })
+    expect(saveIntent(BUILTIN, d, 2)).toEqual({ text: null, restoredFrom: 2 })
+  })
+})
+
+describe('isDirty', () => {
+  it('ignores whitespace-only differences, which the payload would trim away anyway', () => {
+    expect(isDirty(`  ${BUILTIN}\n`, detail())).toBe(false)
+    expect(isDirty(`${BUILTIN} and more`, detail())).toBe(true)
+  })
+})
+
+describe('draftForRevision', () => {
+  it('loads a revert revision as the built-in text', () => {
+    expect(draftForRevision(rev({ text: null }), detail())).toBe(BUILTIN)
+  })
+
+  it('loads an edited revision as its own text', () => {
+    expect(draftForRevision(rev({ text: 'mine' }), detail())).toBe('mine')
+  })
+})
+
+describe('isRevisionConflict', () => {
+  it('recognises the append-only log’s refusal, and nothing else', () => {
+    expect(
+      isRevisionConflict({ data: { error: { details: { reason: 'prompt_revision_conflict' } } } }),
+    ).toBe(true)
+    expect(
+      isRevisionConflict({ data: { error: { details: { reason: 'unknown_revision' } } } }),
+    ).toBe(false)
+    expect(isRevisionConflict(new Error('offline'))).toBe(false)
+  })
+})

package/app/components/pipeline/AgentPromptEditor.logic.ts

@@ -0,0 +1,60 @@
+import type { AgentPromptDetail, AgentPromptRevision } from '~/types/agent-prompts'
+
+// Pure decision logic for the agent system-prompt editor, split out of the component so the
+// rules below are unit-testable without mounting Nuxt. Each one is a rule about the append-only
+// revision log rather than about rendering, and each has a wrong answer that is silent rather
+// than visible — which is why they are pinned rather than left inline in the template.
+
+/**
+ * What a save should send for the current draft.
+ *
+ * Two rules, both non-obvious:
+ *
+ * - **Text identical to the built-in is a REVERT, not a copy of it.** Storing the copy would pin
+ *   the workspace to today's wording and quietly stop it tracking the product's prompt as that is
+ *   improved — the whole reason the null revision exists.
+ * - **`restoredFrom` only survives while the draft still IS that revision.** It is a claim the
+ *   history renders ("restored from version 3"), so carrying it across an edit would label an
+ *   entry as text it does not contain, and the next person tracing the log is misled by a record
+ *   that looks authoritative. Comparing the text is what makes this total: it cannot be defeated
+ *   by an edit-then-undo, and it needs no keystroke tracking in the component.
+ */
+export function saveIntent(
+  draft: string,
+  detail: Pick<AgentPromptDetail, 'builtinText' | 'revisions'> | null,
+  restoredFrom: number | undefined,
+): { text: string | null; restoredFrom?: number } {
+  const text = draft.trim()
+  const builtin = (detail?.builtinText ?? '').trim()
+  const payload: { text: string | null } = { text: text === builtin ? null : text }
+  const source = detail?.revisions.find((r) => r.revision === restoredFrom)
+  if (!source) return payload
+  // A null-text revision restores the built-in, so its "text" for this comparison is that.
+  const sourceText = (source.text ?? detail?.builtinText ?? '').trim()
+  return sourceText === text ? { ...payload, restoredFrom } : payload
+}
+
+/**
+ * Whether the save button does anything. Trimmed on both sides because the payload is trimmed,
+ * so trailing whitespace alone is not an edit — a save button that enables on it appends a
+ * revision indistinguishable from its predecessor.
+ */
+export function isDirty(draft: string, detail: Pick<AgentPromptDetail, 'effectiveText'> | null) {
+  return draft.trim() !== (detail?.effectiveText ?? '').trim()
+}
+
+/** The text `pick`ing a revision loads into the editor: its own, or the built-in for a revert. */
+export function draftForRevision(
+  revision: AgentPromptRevision,
+  detail: Pick<AgentPromptDetail, 'builtinText'> | null,
+): string {
+  return revision.text ?? detail?.builtinText ?? ''
+}
+
+/** True when an error envelope is the append-only log's concurrent-editor refusal. */
+export function isRevisionConflict(error: unknown): boolean {
+  return (
+    (error as { data?: { error?: { details?: { reason?: string } } } })?.data?.error?.details
+      ?.reason === 'prompt_revision_conflict'
+  )
+}

package/app/components/pipeline/AgentPromptEditor.vue

@@ -0,0 +1,298 @@
+<script setup lang="ts">
+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 {
+  draftForRevision,
+  isDirty,
+  isRevisionConflict,
+  saveIntent,
+} from '~/components/pipeline/AgentPromptEditor.logic'
+
+// The per-workspace system-prompt editor for ONE agent kind, opened from the pipeline builder
+// (where the kinds are actually chosen). It edits the SHIPPED track prompt only: the platform
+// re-applies its own directives on top of whatever is saved here, so they cannot be deleted by
+// accident — and it SHOWS that appended text (`detail.appendedText`, measured server-side from
+// the real composition) rather than describing it, so what the editor promises can never drift
+// from what the dispatch actually sends.
+//
+// History is the point, not a nicety: every save appends a revision and going back is another
+// append, so nothing a user does here can lose the prompt their runs were on last week.
+//
+// The rules about WHAT to send live in ./AgentPromptEditor.logic.ts, unit-tested there: each has
+// a wrong answer that is silently wrong (a mislabelled history entry, a revert stored as a copy)
+// rather than visibly broken.
+
+const props = defineProps<{ agentKind: string | null }>()
+const emit = defineEmits<{ close: [] }>()
+
+const { t } = useI18n()
+const toast = useToast()
+const prompts = useAgentPromptsStore()
+
+const open = computed({
+  get: () => props.agentKind !== null,
+  set: (v: boolean) => {
+    if (!v) emit('close')
+  },
+})
+
+/** The textarea's working copy. Seeded from the effective prompt each time the editor opens. */
+const draft = ref('')
+/**
+ * The revision the working copy was lifted out of, when the user picked one from the history.
+ * Only a CANDIDATE: `saveIntent` drops it unless the draft still matches that revision's text,
+ * so editing after a restore cannot mislabel the entry the next reader tries to trace.
+ */
+const restoredFrom = ref<number | undefined>(undefined)
+/** Whether the built-in is shown beside the editor for comparison. */
+const showBuiltin = ref(false)
+/** Whether the non-editable text the platform appends is expanded. */
+const showDirectives = ref(false)
+
+watch(
+  () => props.agentKind,
+  async (kind) => {
+    if (!kind) {
+      prompts.reset()
+      return
+    }
+    showBuiltin.value = false
+    showDirectives.value = false
+    restoredFrom.value = undefined
+    draft.value = ''
+    try {
+      const detail = await prompts.load(kind)
+      draft.value = detail?.effectiveText ?? ''
+    } catch {
+      toast.add({ title: t('agentPrompt.toast.loadFailed'), color: 'error' })
+      emit('close')
+    }
+  },
+  { immediate: true },
+)
+
+const detail = computed(() => prompts.detail)
+const label = computed(() => (props.agentKind ? agentKindMeta(props.agentKind).label : ''))
+
+/** 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. */
+const canRevert = computed(() => detail.value?.customized === true)
+/** What the platform appends to whatever is saved. Empty ⇒ the panel is not offered at all. */
+const directives = computed(() => detail.value?.appendedText ?? '')
+
+function pick(revision: AgentPromptRevision) {
+  draft.value = draftForRevision(revision, detail.value)
+  restoredFrom.value = revision.revision
+}
+
+function useBuiltin() {
+  draft.value = detail.value?.builtinText ?? ''
+  restoredFrom.value = undefined
+}
+
+async function save() {
+  const kind = props.agentKind
+  if (!kind) return
+  const intent = saveIntent(draft.value, detail.value, restoredFrom.value)
+  try {
+    const saved = await prompts.save(kind, intent.text, intent.restoredFrom)
+    draft.value = saved?.effectiveText ?? draft.value
+    restoredFrom.value = undefined
+    toast.add({ title: t('agentPrompt.toast.saved'), color: 'success', icon: 'i-lucide-check' })
+  } catch (error) {
+    const conflict = isRevisionConflict(error)
+    toast.add({
+      title: conflict ? t('agentPrompt.toast.conflict') : t('agentPrompt.toast.saveFailed'),
+      color: 'error',
+    })
+    // The server's view already replaced the store's on a conflict, so re-seed the textarea
+    // from what actually landed rather than leaving the user editing a lost revision — and drop
+    // the restore candidate with it, since it names a revision from the log we just replaced.
+    if (conflict) {
+      draft.value = prompts.detail?.effectiveText ?? draft.value
+      restoredFrom.value = undefined
+    }
+  }
+}
+
+async function revert() {
+  const kind = props.agentKind
+  if (!kind) return
+  try {
+    const saved = await prompts.save(kind, null)
+    draft.value = saved?.effectiveText ?? draft.value
+    restoredFrom.value = undefined
+    toast.add({ title: t('agentPrompt.toast.reverted'), color: 'success' })
+  } catch {
+    toast.add({ title: t('agentPrompt.toast.saveFailed'), color: 'error' })
+  }
+}
+
+const { d } = useI18n()
+function revisionLabel(revision: AgentPromptRevision): string {
+  return revision.text === null
+    ? t('agentPrompt.revision.builtin', { n: revision.revision })
+    : revision.restoredFrom !== undefined
+      ? t('agentPrompt.revision.restored', { n: revision.revision, from: revision.restoredFrom })
+      : t('agentPrompt.revision.edit', { n: revision.revision })
+}
+</script>
+
+<template>
+  <UModal
+    v-model:open="open"
+    :title="t('agentPrompt.title', { agent: label })"
+    :description="t('agentPrompt.description')"
+    :ui="{ content: 'max-w-[92vw] sm:max-w-3xl lg:max-w-5xl' }"
+  >
+    <template #body>
+      <div v-if="prompts.loadingDetail" class="py-8 text-center text-sm text-slate-400">
+        {{ t('common.loading') }}
+      </div>
+      <div v-else-if="detail" class="flex flex-col gap-3">
+        <div class="flex flex-wrap items-center gap-2 text-xs">
+          <AgentKindIcon v-if="agentKind" :kind="agentKind" icon-class="h-4 w-4" />
+          <span class="font-medium text-slate-200">{{ label }}</span>
+          <UBadge v-if="detail.builtinVersionLabel" color="neutral" variant="subtle" size="sm">
+            {{ detail.builtinVersionLabel }}
+          </UBadge>
+          <UBadge :color="detail.customized ? 'warning' : 'neutral'" variant="subtle" size="sm">
+            {{ detail.customized ? t('agentPrompt.customized') : t('agentPrompt.usingBuiltin') }}
+          </UBadge>
+        </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. -->
+        <p v-if="directives" class="text-[11px] leading-relaxed text-slate-500">
+          {{ t('agentPrompt.managedNotice') }}
+          <UButton
+            variant="link"
+            size="xs"
+            class="px-1 align-baseline"
+            @click="showDirectives = !showDirectives"
+          >
+            {{ showDirectives ? t('agentPrompt.hideAppended') : t('agentPrompt.showAppended') }}
+          </UButton>
+        </p>
+        <div
+          v-if="directives && showDirectives"
+          class="rounded-md border border-slate-800 bg-slate-950/60 p-2"
+        >
+          <h4 class="mb-1 text-[11px] font-semibold uppercase tracking-wide text-slate-400">
+            {{ t('agentPrompt.appendedHeading') }}
+          </h4>
+          <pre
+            class="max-h-64 overflow-auto whitespace-pre-wrap break-words font-mono text-[11px] text-slate-300"
+            >{{ directives.trim() }}</pre>
+        </div>
+
+        <UTextarea
+          v-model="draft"
+          :rows="16"
+          autoresize
+          :maxrows="24"
+          class="font-mono"
+          :placeholder="t('agentPrompt.placeholder')"
+        />
+
+        <div class="flex flex-wrap items-center gap-2">
+          <UButton
+            color="primary"
+            size="sm"
+            icon="i-lucide-save"
+            :loading="prompts.saving"
+            :disabled="!dirty || !draft.trim()"
+            @click="save"
+          >
+            {{ t('agentPrompt.save') }}
+          </UButton>
+          <UButton
+            color="neutral"
+            variant="soft"
+            size="sm"
+            icon="i-lucide-rotate-ccw"
+            :disabled="prompts.saving || !canRevert"
+            @click="revert"
+          >
+            {{ t('agentPrompt.revert') }}
+          </UButton>
+          <UButton
+            color="neutral"
+            variant="ghost"
+            size="sm"
+            icon="i-lucide-file-text"
+            @click="useBuiltin"
+          >
+            {{ t('agentPrompt.loadBuiltin') }}
+          </UButton>
+          <UButton
+            color="neutral"
+            variant="ghost"
+            size="sm"
+            :icon="showBuiltin ? 'i-lucide-eye-off' : 'i-lucide-eye'"
+            @click="showBuiltin = !showBuiltin"
+          >
+            {{ showBuiltin ? t('agentPrompt.hideBuiltin') : t('agentPrompt.showBuiltin') }}
+          </UButton>
+          <span v-if="restoredFrom !== undefined" class="text-[11px] text-slate-400">
+            {{ t('agentPrompt.restoringFrom', { n: restoredFrom }) }}
+          </span>
+        </div>
+
+        <div v-if="showBuiltin" class="rounded-md border border-slate-800 bg-slate-950/60 p-2">
+          <h4 class="mb-1 text-[11px] font-semibold uppercase tracking-wide text-slate-400">
+            {{ t('agentPrompt.builtinHeading') }}
+          </h4>
+          <pre
+            class="max-h-64 overflow-auto whitespace-pre-wrap break-words font-mono text-[11px] text-slate-300"
+            >{{ detail.builtinText }}</pre>
+        </div>
+
+        <div>
+          <h4 class="mb-1 text-[11px] font-semibold uppercase tracking-wide text-slate-400">
+            {{ t('agentPrompt.historyHeading') }}
+          </h4>
+          <p v-if="!detail.revisions.length" class="text-[11px] text-slate-500">
+            {{ t('agentPrompt.historyEmpty') }}
+          </p>
+          <ul v-else class="max-h-52 divide-y divide-slate-800 overflow-y-auto text-xs">
+            <li
+              v-for="revision in detail.revisions"
+              :key="revision.revision"
+              class="flex items-center gap-2 py-1.5"
+            >
+              <UBadge
+                v-if="revision.revision === detail.revisions[0]?.revision"
+                color="primary"
+                variant="subtle"
+                size="sm"
+              >
+                {{ t('agentPrompt.live') }}
+              </UBadge>
+              <span class="min-w-0 flex-1 truncate text-slate-300">
+                {{ revisionLabel(revision) }}
+              </span>
+              <span class="shrink-0 text-[11px] text-slate-500">
+                {{ d(new Date(revision.createdAt), 'short') }}
+              </span>
+              <UButton
+                color="neutral"
+                variant="ghost"
+                size="xs"
+                icon="i-lucide-history"
+                :title="t('agentPrompt.restoreTooltip')"
+                @click="pick(revision)"
+              >
+                {{ t('agentPrompt.restore') }}
+              </UButton>
+            </li>
+          </ul>
+        </div>
+      </div>
+    </template>
+  </UModal>
+</template>

package/app/components/pipeline/PipelineBuilder.vue

@@ -4,6 +4,8 @@ import { purposeAllowsAgentCategory } from '@cat-factory/contracts'
 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 { showOverrideField } from '~/utils/uiMode'
 import {
   agentKindMeta,
   companionForProducer,
@@ -54,6 +56,24 @@ function toggleGating(i: number) {
 }
 const agents = useAgentsStore()
 const ui = useUiStore()
+const uiMode = useUiModeStore()
+const agentPrompts = useAgentPromptsStore()
+
+// 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
+// the same kind are two views of one prompt.
+const promptEditorKind = ref<AgentKind | null>(null)
+
+/**
+ * Whether the "edit this agent's prompt" affordance shows for a kind. Editing a prompt is an
+ * OVERRIDE of what the product ships, so it follows the override rule: hidden in basic mode
+ * while the kind is running the shipped prompt, and revealed as soon as the workspace actually
+ * carries an override — otherwise a basic-mode user would be running on an edited prompt they
+ * can neither see nor clear.
+ */
+function showPromptEditor(kind: AgentKind): boolean {
+  return showOverrideField(uiMode.isAdvanced, agentPrompts.isCustomized(kind) || null)
+}
 const releaseHealth = useReleaseHealthStore()
 const skills = useSkillsStore()
 
@@ -99,6 +119,10 @@ const open = computed({
 // the snapshot). Best-effort: a failure just leaves the gate hidden.
 watch(open, (isOpen) => {
   if (isOpen) releaseHealth.load().catch(() => {})
+  // The prompt-override index badges the steps whose agent no longer runs the shipped prompt.
+  // 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(() => {})
 })
 
 function add(kind: AgentKind) {
@@ -578,6 +602,21 @@ async function clone(p: Pipeline) {
                     "
                     @click="pipelines.toggleDraftAutoRecommend(unit.index)"
                   />
+                  <!-- System prompt: replace what this agent kind ships with, for every run in
+                     this workspace, with the full revision history to switch back through. -->
+                  <UButton
+                    v-if="showPromptEditor(unit.kind)"
+                    icon="i-lucide-file-pen-line"
+                    :color="agentPrompts.isCustomized(unit.kind) ? 'warning' : 'neutral'"
+                    variant="ghost"
+                    size="xs"
+                    :title="
+                      agentPrompts.isCustomized(unit.kind)
+                        ? t('pipeline.builder.promptEditedTooltip')
+                        : t('pipeline.builder.promptEditTooltip')
+                    "
+                    @click="promptEditorKind = unit.kind"
+                  />
                   <UButton
                     icon="i-lucide-chevron-up"
                     color="neutral"
@@ -642,6 +681,25 @@ async function clone(p: Pipeline) {
                   <span class="min-w-0 flex-1 truncate text-slate-200">
                     {{ agentKindMeta(pipelines.draft[unit.companionIndex]!).label }}
                   </span>
+                  <!-- A companion is an agent kind with a prompt of its own, and this row is its
+                     only route to it — so the affordance belongs here too, not only on producers. -->
+                  <UButton
+                    v-if="showPromptEditor(pipelines.draft[unit.companionIndex]!)"
+                    icon="i-lucide-file-pen-line"
+                    :color="
+                      agentPrompts.isCustomized(pipelines.draft[unit.companionIndex]!)
+                        ? 'warning'
+                        : 'neutral'
+                    "
+                    variant="ghost"
+                    size="xs"
+                    :title="
+                      agentPrompts.isCustomized(pipelines.draft[unit.companionIndex]!)
+                        ? t('pipeline.builder.promptEditedTooltip')
+                        : t('pipeline.builder.promptEditTooltip')
+                    "
+                    @click="promptEditorKind = pipelines.draft[unit.companionIndex]!"
+                  />
                   <UButton
                     :icon="
                       pipelines.draftGating[unit.companionIndex]?.enabled
@@ -1147,4 +1205,8 @@ async function clone(p: Pipeline) {
       </div>
     </template>
   </UModal>
+
+  <!-- The per-workspace system-prompt editor for one agent kind. Mounted alongside the builder
+       (not inside its slideover body) so its own modal isn't nested inside the scrolling column. -->
+  <AgentPromptEditor :agent-kind="promptEditorKind" @close="promptEditorKind = null" />
 </template>

package/app/components/sandbox/SandboxPanel.vue

@@ -10,6 +10,7 @@ import type {
   SandboxExperimentStatus,
   SandboxFixtureKind,
   SandboxGrade,
+  SandboxPromptOrigin,
   SandboxPromptVersion,
   SandboxRun,
 } from '~/types/sandbox'
@@ -35,6 +36,47 @@ const FIXTURE_KIND_LABEL = computed<Record<SandboxFixtureKind, string>>(() => ({
   'repo-feature': t('sandbox.fixtureKind.repo-feature'),
   'repo-bug': t('sandbox.fixtureKind.repo-bug'),
 }))
+/**
+ * Badge colour per prompt origin. An exhaustive Record over the closed union rather than a
+ * ternary, so adding an origin fails the typecheck here instead of silently rendering as
+ * "candidate" — the drift guard the i18n conventions ask for on enum-keyed lookups.
+ */
+const PROMPT_ORIGIN_COLOR: Record<SandboxPromptOrigin, 'neutral' | 'primary' | 'warning'> = {
+  baseline: 'neutral',
+  candidate: 'primary',
+  workspace: 'warning',
+}
+
+/** Which version is mid-promotion, so only its button spins. */
+const promoting = ref<string | null>(null)
+
+/**
+ * Promotion is offered on anything that is not already what the workspace runs: a graded
+ * candidate (the point of the tool) and an older workspace revision (rolling back). Not on the
+ * live row, where it is a no-op the backend would swallow anyway — and not on a shipped baseline,
+ * since "run what the product ships" is the revert in the prompt editor, not a promotion that
+ * would pin today's wording as a stored override.
+ */
+function canPromote(version: SandboxPromptVersion): boolean {
+  return version.origin !== 'baseline' && version.live !== true
+}
+
+async function promote(version: SandboxPromptVersion) {
+  promoting.value = version.id
+  try {
+    await store.promotePrompt(version)
+    toast.add({
+      title: t('sandbox.prompts.promoted', { agent: version.agentKind }),
+      color: 'success',
+      icon: 'i-lucide-rocket',
+    })
+  } catch {
+    toast.add({ title: t('sandbox.prompts.promoteFailed'), color: 'error' })
+  } finally {
+    promoting.value = null
+  }
+}
+
 const FIXTURE_ORIGIN_LABEL = computed<Record<'builtin' | 'custom', string>>(() => ({
   builtin: t('sandbox.fixtureOrigin.builtin'),
   custom: t('sandbox.fixtureOrigin.custom'),
@@ -508,17 +550,20 @@ async function archive(prompt: SandboxPromptVersion) {
               <div class="min-w-0">
                 <div class="flex items-center gap-2">
                   <span class="truncate text-slate-200">{{ p.name }}</span>
-                  <UBadge
-                    :color="p.origin === 'baseline' ? 'neutral' : 'primary'"
-                    variant="soft"
-                    size="xs"
-                  >
+                  <UBadge :color="PROMPT_ORIGIN_COLOR[p.origin]" variant="soft" size="xs">
                     {{
                       p.origin === 'baseline'
                         ? t('sandbox.baseline')
                         : t('sandbox.versionLabel', { version: p.version })
                     }}
                   </UBadge>
+                  <UBadge v-if="p.origin === 'workspace'" color="warning" variant="soft" size="xs">
+                    {{
+                      p.live
+                        ? t('sandbox.prompts.liveInWorkspace')
+                        : t('sandbox.prompts.fromWorkspace')
+                    }}
+                  </UBadge>
                 </div>
                 <span class="text-[11px] text-slate-500">{{ p.agentKind }}</span>
               </div>
@@ -535,6 +580,19 @@ async function archive(prompt: SandboxPromptVersion) {
                   "
                   @click="edit(p)"
                 />
+                <!-- Deploy: make this version the workspace's live prompt for its agent kind.
+                     Offered on a graded candidate and on an older workspace revision (rolling
+                     back), but not on the one already live, where it would be a no-op. -->
+                <UButton
+                  v-if="canPromote(p)"
+                  icon="i-lucide-rocket"
+                  color="primary"
+                  variant="ghost"
+                  size="xs"
+                  :loading="promoting === p.id"
+                  :title="t('sandbox.prompts.promoteTitle')"
+                  @click="promote(p)"
+                />
                 <UButton
                   v-if="p.origin === 'candidate'"
                   icon="i-lucide-archive"