@cat-factory/app 0.276.0 → 0.277.0

package/app/components/binaryCandidates/BinaryCandidatesWindow.vue

@@ -26,6 +26,7 @@ import {
   binaryCandidateView,
 } from '~/utils/binaryCandidates'
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
+import StoredAssetView from '~/components/binaryOutput/StoredAssetView.vue'
 
 const execution = useExecutionStore()
 const board = useBoardStore()
@@ -194,8 +195,19 @@ async function onKeep() {
             data-testid="binary-candidate-card"
             @click="toggle(row.id)"
           >
+            <!-- Staged through the platform's OWN asset storage: we hold the bytes, so the card
+                 renders them (and offers to open or save one) rather than waiting for a public
+                 link the shipped storage never issues. Checked first because a candidate can
+                 carry both, and ours is the one that is definitely still there. -->
+            <StoredAssetView
+              v-if="row.assetId"
+              :asset-id="row.assetId"
+              :content-type="row.contentType"
+              :label="row.label ?? row.subject"
+              class="mb-2"
+            />
             <img
-              v-if="row.previewUrl"
+              v-else-if="row.previewUrl"
               :src="row.previewUrl"
               :alt="row.label ?? row.id"
               class="mb-2 max-h-56 w-full rounded object-contain"

package/app/components/binaryOutput/BinaryOutputReport.vue

@@ -16,6 +16,7 @@ import type { PipelineStep } from '~/types/execution'
 import { BINARY_OUTPUT_STATE_KEYS, binaryOutputView } from '~/utils/binaryOutput'
 import { binaryCandidateView } from '~/utils/binaryCandidates'
 import CopyButton from '~/components/common/CopyButton.vue'
+import StoredAssetView from '~/components/binaryOutput/StoredAssetView.vue'
 
 // Two callers, one renderer — the same split `StepEffortReport` makes: the generic step-detail
 // panel drops it in as a `card` (its own heading + border, among the other detail sections),
@@ -135,7 +136,13 @@ const state = computed(() => {
 
     <!-- The artifacts. `location` is the service's OWN addressing — an object key, a path, a
          URL — recorded verbatim and never interpreted, so it renders as copyable text and
-         never as a link. -->
+         never as a link.
+         The ONE exception is an artifact stored through the platform's own asset storage, where
+         the location is an id for bytes WE hold: there the row also shows the thing itself, and
+         offers to open or save it. That is not a reinterpretation of the location, it is the
+         join `binaryOutputView` already made (`row.assetId` is null unless the service is ours
+         AND the location is a well-formed id), and it is the difference between a report that
+         says where the work went and one that shows it. -->
     <ul v-if="view.rows.length" class="space-y-1.5">
       <li
         v-for="(row, i) in view.rows"
@@ -144,6 +151,13 @@ const state = computed(() => {
         data-testid="binary-output-artifact"
       >
         <CopyButton :text="row.location" class="absolute end-1 top-1" />
+        <StoredAssetView
+          v-if="row.assetId"
+          :asset-id="row.assetId"
+          :content-type="row.contentType"
+          :label="row.entity ?? row.description"
+          class="mb-2 pe-8"
+        />
         <code class="block break-all pe-8 font-mono text-[11px] text-slate-200">{{
           row.location
         }}</code>

package/app/components/binaryOutput/StoredAssetView.vue

@@ -0,0 +1,134 @@
+<script setup lang="ts">
+// A stored artifact the PLATFORM holds the bytes for: what it looks like, and the two things a
+// person wants to do with it afterwards.
+//
+// This is the half of the media flow that only works because the shipped asset storage is our
+// own. An artifact in an org's private bucket is a location string and, at best, whatever preview
+// link that service chose to issue; one stored here is bytes we can serve, so the run's report can
+// show the picture, open it full size, and hand the file over to be saved elsewhere.
+//
+// The bytes are behind the workspace's authenticated blob route, so an `<img src>` cannot point at
+// them: they are fetched as a blob and turned into an object URL (`useArtifactBlobs`, the same
+// composable the visual-confirmation gate uses). That is also why the DOWNLOAD is an `<a download>`
+// over the object URL rather than a link to the API: a plain link would open an authenticated
+// request the browser has no session header for.
+//
+// Whether the artifact renders as a picture is `rendersInlineAsImage` over the media type the
+// SERVER SERVED, not the one the producing agent declared. The declaration is optional and
+// model-authored: a step that stores a PNG and says nothing about it would render as a generic
+// file, and one that mislabels a bundle as an image would render a broken `<img>` reporting
+// itself as loaded, with no error affordance because the fetch genuinely succeeded. The served
+// type is the same judgement the server already made when it decided whether to answer inline or
+// as an attachment, so a row and the response behind it can no longer disagree. The declared type
+// stays as the LABEL on a non-image row, which is what it is good for: it is the agent's own
+// account of the file, where the served type only ever says image-or-not.
+//
+// Everything that is not a picture (a 3D model, an audio file, a PDF) is a legitimate outcome and
+// NOT a failure: it renders as a named file with the same two actions, because the point of the
+// surface is the file, not the thumbnail.
+import { computed, onUnmounted, watch } from 'vue'
+import { rendersInlineAsImage } from '@cat-factory/contracts'
+import { useArtifactBlobs } from '~/composables/useArtifactBlobs'
+
+const props = withDefaults(
+  defineProps<{
+    /** The platform artifact id (`art_…`) resolved off the row's service + location. */
+    assetId: string
+    /** The media type the agent reported. Shown as the label on a non-image row; see above. */
+    contentType?: string | undefined
+    /** What to call the file a person saves, and the image's alt text. */
+    label?: string | undefined
+    /** Cap on the rendered preview's height, so a report row and a comparison card can differ. */
+    previewClass?: string
+  }>(),
+  { contentType: undefined, label: undefined, previewClass: 'max-h-56' },
+)
+const { t } = useI18n()
+
+const blobs = useArtifactBlobs()
+onUnmounted(() => blobs.revokeAll())
+
+// Re-resolve when the id changes rather than only on mount: one of these components is reused
+// across the rows of a report that grows over a live run.
+watch(
+  () => props.assetId,
+  (id) => void blobs.resolve(id),
+  { immediate: true },
+)
+
+const url = computed(() => blobs.urlFor(props.assetId))
+const status = computed(() => blobs.statusFor(props.assetId))
+const isImage = computed(() => rendersInlineAsImage(blobs.typeFor(props.assetId)))
+
+/**
+ * The name the saved file takes. Derived from the agent's own label where there is one, because
+ * `art_01H…` tells the person who saves it nothing about what it is; sanitised to the characters
+ * a filename may safely carry, since the label is model-authored text going into a download.
+ */
+const filename = computed(() => {
+  const base = (props.label ?? '')
+    .trim()
+    .replace(/[^A-Za-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+  return base ? base.slice(0, 80) : props.assetId
+})
+</script>
+
+<template>
+  <div class="space-y-1.5" data-testid="stored-asset">
+    <img
+      v-if="isImage && url"
+      :src="url"
+      :alt="label ?? assetId"
+      class="w-full rounded object-contain"
+      :class="previewClass"
+      data-testid="stored-asset-preview"
+    />
+    <!-- Not a picture, and that is an ordinary outcome for a media step: a mesh, a sound and a
+         PDF are all deliverables, so the row states what it is rather than showing a broken
+         frame. -->
+    <p
+      v-else-if="!isImage && url"
+      class="flex items-center gap-1.5 rounded bg-slate-800/60 px-2 py-1.5 text-[11px] text-slate-300"
+      data-testid="stored-asset-file"
+    >
+      <UIcon name="i-lucide-file" class="h-3.5 w-3.5 shrink-0" />
+      <span class="truncate">{{ contentType ?? t('binaryOutput.asset.unknownType') }}</span>
+    </p>
+    <p
+      v-else-if="status === 'error'"
+      class="flex items-center gap-1.5 text-[11px] text-amber-300"
+      data-testid="stored-asset-error"
+    >
+      <span>{{ t('binaryOutput.asset.loadFailed') }}</span>
+      <UButton size="xs" variant="link" @click.stop="blobs.retry(assetId)">
+        {{ t('binaryOutput.asset.retry') }}
+      </UButton>
+    </p>
+    <p v-else class="text-[11px] text-slate-500" data-testid="stored-asset-loading">
+      {{ t('binaryOutput.asset.loading') }}
+    </p>
+
+    <!-- The two things a person does with a delivered asset. Both hang off the object URL, so
+         they appear only once the bytes are in hand. -->
+    <div v-if="url" class="flex items-center gap-3 text-[11px]">
+      <a
+        :href="url"
+        target="_blank"
+        rel="noopener"
+        class="text-sky-300 hover:underline"
+        data-testid="stored-asset-open"
+        @click.stop
+        >{{ t('binaryOutput.asset.open') }}</a
+      >
+      <a
+        :href="url"
+        :download="filename"
+        class="text-sky-300 hover:underline"
+        data-testid="stored-asset-download"
+        @click.stop
+        >{{ t('binaryOutput.asset.download') }}</a
+      >
+    </div>
+  </div>
+</template>

package/app/components/board/AddTaskModal.vue

@@ -104,6 +104,7 @@ const TASK_TYPES = computed<{ value: TaskTypeChoice; label: string; icon: string
       icon: 'i-lucide-clipboard-check',
     },
     { value: 'ralph', label: t('board.addTask.types.ralph'), icon: 'i-lucide-infinity' },
+    { value: 'media', label: t('board.addTask.types.media'), icon: 'i-lucide-image-plus' },
     { value: 'recurring', label: t('board.addTask.types.recurring'), icon: 'i-lucide-repeat' },
   ]
   // A document repository only accepts document/spike tasks (see BoardService.addTask).
@@ -400,16 +401,20 @@ const selectablePipelines = computed(() =>
 // must appear in the form BEFORE creation:
 //   - `ralph` needs its preset so the per-task validation command + iteration budget the `ralph`
 //     agent contributes surface for editing ("choose at run time" would be a dead end);
-//   - a `document` task defaults to `pl_document` and a `review` task to `pl_review` so their
-//     purpose-narrowed picker (the `purpose` gate hides every non-document / non-review pipeline)
-//     is never rendered empty.
+//   - a `document` task defaults to `pl_document`, a `review` task to `pl_review` and a `media`
+//     task to `pl_media` so their purpose-narrowed picker (the `purpose` gate hides every pipeline
+//     of another purpose) is never rendered empty.
 // The other typed default (spike) carries no up-front config and doesn't narrow its picker, so the
 // modal leaves `pipelineId` unset and `BoardService` applies the backend type-default at creation.
-// Keep these ids in step with the backend helper.
+// Keep these ids in step with the backend helper. The test for membership is the NARROWING, not the
+// config: a type whose picker `pipelineAllowedForTaskType` reduces to one purpose has to name its
+// default here, because every fallback below is a BUILD-purpose pipeline the narrowed picker then
+// rejects, leaving the form open on an empty selection.
 const DEFAULT_PIPELINE_FOR_TYPE: Partial<Record<TaskTypeChoice, string>> = {
   ralph: 'pl_ralph',
   document: 'pl_document',
   review: 'pl_review',
+  media: 'pl_media',
 }
 /**
  * The pipeline a task type opens with: a custom type's registered `defaultPipelineId`, else the

package/app/components/palettes/PipelinePurposeSelect.vue

@@ -30,6 +30,7 @@ const PURPOSE_LABELS = computed<Record<PipelinePurpose, string>>(() => ({
   review: t('pipeline.builder.purposeOption.review'),
   research: t('pipeline.builder.purposeOption.research'),
   planning: t('pipeline.builder.purposeOption.planning'),
+  media: t('pipeline.builder.purposeOption.media'),
 }))
 
 // The button text. A stored purpose this build has no label for is NAMED as unrecognised and

package/app/components/settings/WorkspaceSettingsPanel.vue

@@ -148,7 +148,7 @@ const tabsUi = {
 // so the config surface pins the built-in set it renders inputs for — a custom type buckets on its
 // own id server-side (`RunAdmission`) and is not configured here. Keying the records below off this
 // finite union (not the open `CreateTaskType`) keeps them exhaustive + undefined-free.
-type LimitTaskType = 'feature' | 'bug' | 'document' | 'spike' | 'review' | 'ralph'
+type LimitTaskType = 'feature' | 'bug' | 'document' | 'spike' | 'review' | 'ralph' | 'media'
 const TASK_TYPES: LimitTaskType[] = ['feature', 'bug', 'document', 'spike']
 
 // Per-task-type label for the "Max {type} tasks" inputs. An exhaustive Record keyed off
@@ -161,6 +161,7 @@ const TASK_TYPE_KEYS: Record<LimitTaskType, string> = {
   spike: 'settings.workspaceSettings.taskTypes.spike',
   review: 'settings.workspaceSettings.taskTypes.review',
   ralph: 'settings.workspaceSettings.taskTypes.ralph',
+  media: 'settings.workspaceSettings.taskTypes.media',
 }
 
 const MODES = computed<{ value: TaskLimitMode; label: string }[]>(() => [

package/app/composables/api/visualConfirm.ts

@@ -49,12 +49,21 @@ export function visualConfirmApi({ send, ws, http }: ApiContext) {
     },
 
     // Fetch a stored artifact's bytes and turn them into an object URL for an <img>.
-    fetchArtifactBlobUrl: async (workspaceId: string, artifactId: string): Promise<string> => {
+    //
+    // The blob's own `type` comes back beside the URL because it is the media type the SERVER
+    // decided to serve these bytes as, which is the only one a caller may render from. What the
+    // producing agent declared is a claim about a file; this is what the response actually is,
+    // after `blobResponseHeaders` has clamped anything outside the inline-image list down to
+    // `application/octet-stream`.
+    fetchArtifactBlob: async (
+      workspaceId: string,
+      artifactId: string,
+    ): Promise<{ url: string; contentType: string }> => {
       const blob: Blob = await http(
         `${ws(workspaceId)}/artifacts/${encodeURIComponent(artifactId)}/blob`,
         { method: 'GET', responseType: 'blob' },
       )
-      return URL.createObjectURL(blob)
+      return { url: URL.createObjectURL(blob), contentType: blob.type }
     },
   }
 }

package/app/composables/useArtifactBlobs.spec.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it, vi } from 'vitest'
+import { useArtifactBlobs } from '~/composables/useArtifactBlobs'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+// What a resolved artifact reports about ITSELF, and why the answer is not the declaration that
+// came with it.
+//
+// A stored asset carries two media types: the one the producing agent declared (optional,
+// model-authored, a claim about a file) and the one the server SERVES the bytes as, after
+// `blobResponseHeaders` has clamped anything outside the inline-image list down to
+// `application/octet-stream`. Only the second is a fact about the response, so it is the one a
+// surface may decide picture-versus-file from. Deciding from the declaration is wrong in both
+// directions: an undeclared PNG renders as a generic file, and a mis-declared bundle renders as a
+// broken `<img>` that reports itself as loaded, because the fetch genuinely succeeded.
+
+function stubApi(contentType: string): { calls: number } {
+  const state = { calls: 0 }
+  vi.stubGlobal('useApi', () => ({
+    fetchArtifactBlob: async (_ws: string, id: string) => {
+      state.calls += 1
+      return { url: `blob:${id}`, contentType }
+    },
+  }))
+  return state
+}
+
+function blobs(contentType: string) {
+  const calls = stubApi(contentType)
+  useWorkspaceStore().workspaceId = 'ws_1'
+  return { blobs: useArtifactBlobs(), calls }
+}
+
+describe('useArtifactBlobs', () => {
+  it('records the media type the server served, beside the URL', async () => {
+    const { blobs: cache } = blobs('image/png')
+    await cache.resolve('art_1')
+    expect(cache.urlFor('art_1')).toBe('blob:art_1')
+    expect(cache.typeFor('art_1')).toBe('image/png')
+  })
+
+  it('reports the clamped type for bytes the server refused to serve inline', async () => {
+    // A GLB, a zip, a PDF, or an image type the allow-list does not carry: the response is an
+    // attachment, and a row that pointed an `<img>` at it would render a broken frame with the
+    // load reported as successful.
+    const { blobs: cache } = blobs('application/octet-stream')
+    await cache.resolve('art_1')
+    expect(cache.typeFor('art_1')).toBe('application/octet-stream')
+  })
+
+  it('knows nothing about a type until the bytes are in hand', async () => {
+    // The loading state has no answer to give, which is what keeps a surface from committing to
+    // picture-or-file before the response says which.
+    const { blobs: cache } = blobs('image/png')
+    expect(cache.typeFor('art_1')).toBeUndefined()
+    await cache.resolve('art_1')
+    expect(cache.typeFor('art_1')).toBe('image/png')
+  })
+
+  it('drops the recorded type on a retry, so a re-fetch cannot be read through the old one', async () => {
+    const { blobs: cache } = blobs('image/png')
+    await cache.resolve('art_1')
+    const pending = cache.retry('art_1')
+    expect(cache.typeFor('art_1')).toBeUndefined()
+    await pending
+    expect(cache.typeFor('art_1')).toBe('image/png')
+  })
+
+  it('forgets every type when the owning component unmounts', async () => {
+    // The cache is per component and `revokeAll` is what releases the bytes; a type left behind
+    // would outlive the URL it describes.
+    const { blobs: cache } = blobs('image/png')
+    await cache.resolve('art_1')
+    cache.revokeAll()
+    expect(cache.typeFor('art_1')).toBeUndefined()
+  })
+})

package/app/composables/useArtifactBlobs.ts

@@ -23,6 +23,17 @@ export function useArtifactBlobs() {
 
   /** artifactId → object URL (reactive so templates re-render when a blob resolves). */
   const urls = reactive<Record<string, string>>({})
+  /**
+   * artifactId → the media type the SERVER served these bytes as.
+   *
+   * The one a surface may decide from. A stored artifact also carries a DECLARED content type,
+   * which for an asset is the agent's own claim about the file it uploaded and is optional; the
+   * serve path meanwhile clamps anything outside the inline-image list to
+   * `application/octet-stream`. So a row deciding picture-versus-file from the declaration gets it
+   * wrong in both directions: an undeclared PNG renders as a generic file, and a mis-declared
+   * bundle renders as a broken `<img>` with the load reported as successful.
+   */
+  const types = reactive<Record<string, string>>({})
   /** artifactId → fetch status, drives loading / error / retry affordances. */
   const status = reactive<Record<string, ArtifactBlobStatus>>({})
   /** In-flight promises, so concurrent `resolve(id)` calls share one fetch + one blob. */
@@ -43,6 +54,11 @@ export function useArtifactBlobs() {
     return id ? (status[id] ?? 'idle') : 'idle'
   }
 
+  /** The media type the server served this artifact as, once its bytes are in hand. */
+  function typeFor(id: string | null | undefined): string | undefined {
+    return id ? types[id] : undefined
+  }
+
   /** Resolve an artifact to an object URL (cached + deduped). Returns null on failure. */
   function resolve(id: string | null | undefined): Promise<string | null> {
     if (!id || disposed) return Promise.resolve(null)
@@ -53,19 +69,22 @@ export function useArtifactBlobs() {
 
     status[id] = 'loading'
     const p = api
-      .fetchArtifactBlobUrl(ws.requireId(), id)
-      .then((url) => {
+      .fetchArtifactBlob(ws.requireId(), id)
+      .then(({ url, contentType }) => {
         // The owner unmounted while this was in flight: revoke the freshly-minted URL
         // instead of stranding it in the cleared cache.
         if (disposed) {
           try {
             URL.revokeObjectURL(url)
           } catch {
-            // Already revoked / unsupported environment — nothing to do.
+            // Already revoked / unsupported environment, nothing to do.
           }
           return null
         }
         urls[id] = url
+        // Written BEFORE the status flips to `ready`, so a watcher reacting to the status never
+        // reads a resolved artifact whose served type has not landed yet.
+        if (contentType) types[id] = contentType
         status[id] = 'ready'
         return url
       })
@@ -91,6 +110,7 @@ export function useArtifactBlobs() {
       }
     }
     delete urls[id]
+    delete types[id]
     status[id] = 'idle'
     inFlight.delete(id)
     return resolve(id)
@@ -110,11 +130,12 @@ export function useArtifactBlobs() {
       }
     }
     for (const k of Object.keys(urls)) delete urls[k]
+    for (const k of Object.keys(types)) delete types[k]
     for (const k of Object.keys(status)) delete status[k]
     inFlight.clear()
   }
 
-  return { urls, status, urlFor, statusFor, resolve, retry, revokeAll }
+  return { urls, types, status, urlFor, statusFor, typeFor, resolve, retry, revokeAll }
 }
 
 export type ArtifactBlobs = ReturnType<typeof useArtifactBlobs>

package/app/utils/binaryCandidates.ts

@@ -1,3 +1,4 @@
+import { platformAssetIdOf } from '@cat-factory/contracts'
 import type { BinaryCandidate, BinaryCandidateStepState, PipelineStep } from '~/types/execution'
 
 // ---------------------------------------------------------------------------
@@ -23,6 +24,17 @@ export interface BinaryCandidateRow extends BinaryCandidate {
   kept: boolean
   /** The id it is to be stored under, when the person who kept it assigned one. */
   storeAs?: string
+  /**
+   * The platform's own artifact id, when this candidate was staged through the platform's asset
+   * storage rather than an org's own service.
+   *
+   * It is the OTHER way a candidate gets a preview, and the one that works on a private estate:
+   * `previewUrl` needs the storage service to have issued a public link, which ours never does
+   * (its bytes are behind the workspace's own authenticated blob route). Without this a
+   * deployment using the shipped storage would compare candidates it could not see, which is the
+   * one thing this window exists to make possible.
+   */
+  assetId: string | null
 }
 
 /** The candidates for one subject, which is the unit a person compares. */
@@ -81,6 +93,7 @@ export function binaryCandidateView(
     const choice = kept.get(candidate.id)
     group.rows.push({
       ...candidate,
+      assetId: platformAssetIdOf(candidate),
       kept: choice !== undefined,
       ...(choice?.storeAs ? { storeAs: choice.storeAs } : {}),
     })
@@ -91,7 +104,12 @@ export function binaryCandidateView(
     awaiting: state.status === 'awaiting_choice',
     multiSelect: state.multiSelect === true,
     automatic: state.choice?.automatic === true,
-    withoutPreview: state.candidates.filter((candidate) => !candidate.previewUrl).length,
+    // Counts a candidate with NEITHER kind of preview: a service-issued link, or bytes the
+    // platform holds itself. Reading only `previewUrl` here would report every candidate of every
+    // run on the shipped storage as unviewable while the window was rendering all of them.
+    withoutPreview: state.candidates.filter(
+      (candidate) => !candidate.previewUrl && !platformAssetIdOf(candidate),
+    ).length,
   }
 }
 

package/app/utils/binaryOutput.ts

@@ -9,6 +9,7 @@ import {
   isHarnessTransport,
   modalityCarriesPixelDimensions,
   normalizeMediaType,
+  platformAssetIdOf,
   requiredBinaryCapabilities,
 } from '@cat-factory/contracts'
 import type {
@@ -103,6 +104,17 @@ export interface BinaryOutputRow extends BinaryOutputArtifact {
    * instead of letting an absent measurement read as a passing one.
    */
   missized: boolean
+  /**
+   * The platform's own artifact id, when THIS deployment is what holds the bytes: the row's
+   * service is the platform asset store and its `location` is a well-formed artifact id.
+   *
+   * It is what turns a location string into a picture the reader can look at and a file they can
+   * save, which is the whole difference between an asset in our storage and one in an org's
+   * private bucket. Null covers BOTH "stored elsewhere" and "stored here, but the location is not
+   * an id". A model's location is prose, and a paraphrased one costs the row its preview and
+   * never its record.
+   */
+  assetId: string | null
 }
 
 /**
@@ -301,6 +313,7 @@ export function binaryOutputView(step: PipelineStep | null | undefined): BinaryO
     unknown: unknown.has(artifact.service),
     // An UNATTRIBUTED row (no `generator` claimed) is not unknown — see the field's own note.
     generatorUnknown: artifact.generator !== undefined && unknownGenerators.has(artifact.generator),
+    assetId: platformAssetIdOf(artifact),
     // An UNMEASURED row is not missized either: absent dimensions are counted by
     // `sizeUnreported`, never folded in here.
     missized:

package/app/utils/catalog.ts

@@ -959,6 +959,12 @@ export const TASK_TYPE_META: Record<string, TaskTypeMeta> = {
     color: '#a78bfa',
     labelKey: 'board.addTask.types.ralph',
   },
+  media: {
+    taskType: 'media',
+    icon: 'i-lucide-image-plus',
+    color: '#f472b6',
+    labelKey: 'board.addTask.types.media',
+  },
   recurring: {
     taskType: 'recurring',
     icon: 'i-lucide-repeat',

package/i18n/locales/de.json

@@ -1077,7 +1077,8 @@
         "document": "Dokument",
         "spike": "Spike",
         "review": "Review",
-        "ralph": "Ralph-Schleife"
+        "ralph": "Ralph-Schleife",
+        "media": "Medien"
       },
       "reviewFriction": {
         "heading": "Review-Rückstau-Bremse",
@@ -2982,6 +2983,7 @@
         "bug": "Bug",
         "document": "Dokument",
         "spike": "Spike",
+        "media": "Medien",
         "recurring": "Wiederkehrend",
         "review": "Review",
         "ralph": "Ralph-Schleife"
@@ -4498,7 +4500,8 @@
         "document": "Dokumentation",
         "review": "Review",
         "research": "Recherche",
-        "planning": "Planung"
+        "planning": "Planung",
+        "media": "Medien"
       },
       "strategyOption": {
         "specialist-panel": "Spezialisten-Panel",
@@ -5396,6 +5399,14 @@
       "automatic": "{total} Kandidat wurde erzeugt und ohne Prüfung automatisch behalten.",
       "chosen": "{kept} von {total} erzeugten Kandidaten wurden behalten.",
       "awaiting": "{total} Kandidaten wurden erzeugt und warten auf den Vergleich."
+    },
+    "asset": {
+      "loading": "Datei wird geladen …",
+      "loadFailed": "Die gespeicherte Datei konnte nicht geladen werden.",
+      "retry": "Erneut versuchen",
+      "open": "Öffnen",
+      "download": "Kopie speichern",
+      "unknownType": "Gespeicherte Datei"
     }
   },
   "brainstorm": {

package/i18n/locales/en.json

@@ -256,6 +256,7 @@
         "bug": "Bug",
         "document": "Document",
         "spike": "Spike",
+        "media": "Media",
         "recurring": "Recurring",
         "review": "Review",
         "ralph": "Ralph loop"
@@ -3929,7 +3930,8 @@
         "document": "document",
         "spike": "spike",
         "review": "review",
-        "ralph": "Ralph loop"
+        "ralph": "Ralph loop",
+        "media": "media"
       },
       "reviewFriction": {
         "heading": "Review-debt friction",
@@ -5132,7 +5134,8 @@
         "document": "Documentation",
         "review": "Review",
         "research": "Research",
-        "planning": "Planning"
+        "planning": "Planning",
+        "media": "Media"
       },
       "strategyOption": {
         "specialist-panel": "Specialist panel",
@@ -6999,6 +7002,14 @@
       "automatic": "{total} candidate was generated and kept automatically, without review.",
       "chosen": "{kept} of {total} generated candidates were kept.",
       "awaiting": "{total} candidates were generated and are waiting to be compared."
+    },
+    "asset": {
+      "loading": "Loading the file…",
+      "loadFailed": "The stored file could not be loaded.",
+      "retry": "Try again",
+      "open": "Open",
+      "download": "Save a copy",
+      "unknownType": "Stored file"
     }
   },
   "sandbox": {

package/i18n/locales/es.json

@@ -220,6 +220,7 @@
         "bug": "Error",
         "document": "Documento",
         "spike": "Spike",
+        "media": "Medios",
         "recurring": "Recurrente",
         "review": "Revisión",
         "ralph": "Bucle Ralph"
@@ -3644,7 +3645,8 @@
         "document": "documento",
         "spike": "spike",
         "review": "revisión",
-        "ralph": "Bucle Ralph"
+        "ralph": "Bucle Ralph",
+        "media": "medios"
       },
       "reviewFriction": {
         "heading": "Fricción por revisión pendiente",
@@ -4962,7 +4964,8 @@
         "document": "Documentación",
         "review": "Revisión",
         "research": "Investigación",
-        "planning": "Planificación"
+        "planning": "Planificación",
+        "media": "Medios"
       },
       "strategyOption": {
         "specialist-panel": "Panel de especialistas",
@@ -6688,6 +6691,14 @@
       "automatic": "Se generó {total} candidato y se conservó automáticamente, sin revisión.",
       "chosen": "Se conservaron {kept} de {total} candidatos generados.",
       "awaiting": "Se generaron {total} candidatos y están a la espera de compararse."
+    },
+    "asset": {
+      "loading": "Cargando el archivo…",
+      "loadFailed": "No se pudo cargar el archivo almacenado.",
+      "retry": "Reintentar",
+      "open": "Abrir",
+      "download": "Guardar una copia",
+      "unknownType": "Archivo almacenado"
     }
   },
   "sandbox": {

package/i18n/locales/fr.json

@@ -220,6 +220,7 @@
         "bug": "Bug",
         "document": "Document",
         "spike": "Spike",
+        "media": "Média",
         "recurring": "Récurrent",
         "review": "Revue",
         "ralph": "Boucle Ralph"
@@ -3644,7 +3645,8 @@
         "document": "document",
         "spike": "spike",
         "review": "revue",
-        "ralph": "Boucle Ralph"
+        "ralph": "Boucle Ralph",
+        "media": "média"
       },
       "reviewFriction": {
         "heading": "Friction de dette de revue",
@@ -4962,7 +4964,8 @@
         "document": "Documentation",
         "review": "Revue",
         "research": "Recherche",
-        "planning": "Planification"
+        "planning": "Planification",
+        "media": "Média"
       },
       "strategyOption": {
         "specialist-panel": "Panel de spécialistes",
@@ -6688,6 +6691,14 @@
       "automatic": "{total} candidat a été généré et conservé automatiquement, sans examen.",
       "chosen": "{kept} des {total} candidats générés ont été conservés.",
       "awaiting": "{total} candidats ont été générés et attendent d’être comparés."
+    },
+    "asset": {
+      "loading": "Chargement du fichier…",
+      "loadFailed": "Le fichier stocké n’a pas pu être chargé.",
+      "retry": "Réessayer",
+      "open": "Ouvrir",
+      "download": "Enregistrer une copie",
+      "unknownType": "Fichier stocké"
     }
   },
   "sandbox": {

package/i18n/locales/he.json

@@ -220,6 +220,7 @@
         "bug": "באג",
         "document": "מסמך",
         "spike": "ספייק",
+        "media": "מדיה",
         "recurring": "מחזורי",
         "review": "סקירה",
         "ralph": "לולאת Ralph"
@@ -3786,7 +3787,8 @@
         "document": "מסמך",
         "spike": "חקירה",
         "review": "סקירה",
-        "ralph": "לולאת Ralph"
+        "ralph": "לולאת Ralph",
+        "media": "מדיה"
       },
       "reviewFriction": {
         "heading": "חיכוך חוב סקירה",
@@ -4962,7 +4964,8 @@
         "document": "תיעוד",
         "review": "סקירה",
         "research": "מחקר",
-        "planning": "תכנון"
+        "planning": "תכנון",
+        "media": "מדיה"
       },
       "strategyOption": {
         "specialist-panel": "פאנל מומחים",
@@ -6688,6 +6691,14 @@
       "automatic": "נוצר {total} מועמד ונשמר אוטומטית, ללא בדיקה.",
       "chosen": "נשמרו {kept} מתוך {total} מועמדים שנוצרו.",
       "awaiting": "נוצרו {total} מועמדים והם ממתינים להשוואה."
+    },
+    "asset": {
+      "loading": "טוען את הקובץ…",
+      "loadFailed": "לא ניתן היה לטעון את הקובץ השמור.",
+      "retry": "נסה שוב",
+      "open": "פתיחה",
+      "download": "שמירת עותק",
+      "unknownType": "קובץ שמור"
     }
   },
   "sandbox": {

package/i18n/locales/it.json

@@ -1077,7 +1077,8 @@
         "document": "documento",
         "spike": "spike",
         "review": "revisione",
-        "ralph": "Ciclo Ralph"
+        "ralph": "Ciclo Ralph",
+        "media": "media"
       },
       "reviewFriction": {
         "heading": "Attrito per revisioni in sospeso",
@@ -2982,6 +2983,7 @@
         "bug": "Bug",
         "document": "Documento",
         "spike": "Spike",
+        "media": "Media",
         "recurring": "Ricorrente",
         "review": "Revisione",
         "ralph": "Ciclo Ralph"
@@ -4498,7 +4500,8 @@
         "document": "Documentazione",
         "review": "Revisione",
         "research": "Ricerca",
-        "planning": "Pianificazione"
+        "planning": "Pianificazione",
+        "media": "Media"
       },
       "strategyOption": {
         "specialist-panel": "Panel di specialisti",
@@ -5396,6 +5399,14 @@
       "automatic": "È stato generato {total} candidato e tenuto automaticamente, senza revisione.",
       "chosen": "Sono stati tenuti {kept} dei {total} candidati generati.",
       "awaiting": "Sono stati generati {total} candidati e attendono di essere confrontati."
+    },
+    "asset": {
+      "loading": "Caricamento del file…",
+      "loadFailed": "Non è stato possibile caricare il file archiviato.",
+      "retry": "Riprova",
+      "open": "Apri",
+      "download": "Salva una copia",
+      "unknownType": "File archiviato"
     }
   },
   "brainstorm": {

package/i18n/locales/ja.json

@@ -220,6 +220,7 @@
         "bug": "バグ",
         "document": "ドキュメント",
         "spike": "スパイク",
+        "media": "メディア",
         "recurring": "繰り返し",
         "review": "レビュー",
         "ralph": "Ralph ループ"
@@ -3786,7 +3787,8 @@
         "document": "ドキュメント",
         "spike": "スパイク",
         "review": "レビュー",
-        "ralph": "Ralph ループ"
+        "ralph": "Ralph ループ",
+        "media": "メディア"
       },
       "reviewFriction": {
         "heading": "レビュー滞留の摩擦",
@@ -4962,7 +4964,8 @@
         "document": "ドキュメント",
         "review": "レビュー",
         "research": "調査",
-        "planning": "計画"
+        "planning": "計画",
+        "media": "メディア"
       },
       "strategyOption": {
         "specialist-panel": "専門家パネル",
@@ -6688,6 +6691,14 @@
       "automatic": "候補が {total} 件生成され、確認なしで自動的に採用されました。",
       "chosen": "生成された {total} 件の候補のうち {kept} 件が採用されました。",
       "awaiting": "{total} 件の候補が生成され、比較を待っています。"
+    },
+    "asset": {
+      "loading": "ファイルを読み込んでいます…",
+      "loadFailed": "保存されたファイルを読み込めませんでした。",
+      "retry": "再試行",
+      "open": "開く",
+      "download": "コピーを保存",
+      "unknownType": "保存されたファイル"
     }
   },
   "sandbox": {

package/i18n/locales/pl.json

@@ -220,6 +220,7 @@
         "bug": "Błąd",
         "document": "Dokument",
         "spike": "Spike",
+        "media": "Multimedia",
         "recurring": "Cykliczne",
         "review": "Przegląd",
         "ralph": "Pętla Ralph"
@@ -3644,7 +3645,8 @@
         "document": "dokument",
         "spike": "spike",
         "review": "przegląd",
-        "ralph": "Pętla Ralph"
+        "ralph": "Pętla Ralph",
+        "media": "multimedia"
       },
       "reviewFriction": {
         "heading": "Hamulec długu przeglądów",
@@ -4962,7 +4964,8 @@
         "document": "Dokumentacja",
         "review": "Przegląd",
         "research": "Badania",
-        "planning": "Planowanie"
+        "planning": "Planowanie",
+        "media": "Multimedia"
       },
       "strategyOption": {
         "specialist-panel": "Panel specjalistów",
@@ -6688,6 +6691,14 @@
       "automatic": "Wygenerowano {total} kandydata i zachowano go automatycznie, bez przeglądu.",
       "chosen": "Zachowano {kept} z {total} wygenerowanych kandydatów.",
       "awaiting": "Wygenerowano {total} kandydatów i czekają na porównanie."
+    },
+    "asset": {
+      "loading": "Wczytywanie pliku…",
+      "loadFailed": "Nie udało się wczytać zapisanego pliku.",
+      "retry": "Spróbuj ponownie",
+      "open": "Otwórz",
+      "download": "Zapisz kopię",
+      "unknownType": "Zapisany plik"
     }
   },
   "sandbox": {

package/i18n/locales/tr.json

@@ -220,6 +220,7 @@
         "bug": "Hata",
         "document": "Belge",
         "spike": "Spike",
+        "media": "Medya",
         "recurring": "Yinelenen",
         "review": "İnceleme",
         "ralph": "Ralph döngüsü"
@@ -3786,7 +3787,8 @@
         "document": "belge",
         "spike": "inceleme",
         "review": "inceleme",
-        "ralph": "Ralph döngüsü"
+        "ralph": "Ralph döngüsü",
+        "media": "medya"
       },
       "reviewFriction": {
         "heading": "İnceleme borcu sürtünmesi",
@@ -4962,7 +4964,8 @@
         "document": "Dokümantasyon",
         "review": "İnceleme",
         "research": "Araştırma",
-        "planning": "Planlama"
+        "planning": "Planlama",
+        "media": "Medya"
       },
       "strategyOption": {
         "specialist-panel": "Uzman paneli",
@@ -6688,6 +6691,14 @@
       "automatic": "{total} aday üretildi ve inceleme olmadan otomatik olarak tutuldu.",
       "chosen": "Üretilen {total} adayın {kept} tanesi tutuldu.",
       "awaiting": "{total} aday üretildi ve karşılaştırılmayı bekliyor."
+    },
+    "asset": {
+      "loading": "Dosya yükleniyor…",
+      "loadFailed": "Saklanan dosya yüklenemedi.",
+      "retry": "Yeniden dene",
+      "open": "Aç",
+      "download": "Kopyasını kaydet",
+      "unknownType": "Saklanan dosya"
     }
   },
   "sandbox": {

package/i18n/locales/uk.json

@@ -220,6 +220,7 @@
         "bug": "Помилка",
         "document": "Документ",
         "spike": "Spike",
+        "media": "Медіа",
         "recurring": "Періодичне",
         "review": "Огляд",
         "ralph": "Цикл Ralph"
@@ -3644,7 +3645,8 @@
         "document": "документ",
         "spike": "spike",
         "review": "огляд",
-        "ralph": "Цикл Ralph"
+        "ralph": "Цикл Ralph",
+        "media": "медіа"
       },
       "reviewFriction": {
         "heading": "Тертя через борг рев’ю",
@@ -4962,7 +4964,8 @@
         "document": "Документація",
         "review": "Рецензування",
         "research": "Дослідження",
-        "planning": "Планування"
+        "planning": "Планування",
+        "media": "Медіа"
       },
       "strategyOption": {
         "specialist-panel": "Панель фахівців",
@@ -6688,6 +6691,14 @@
       "automatic": "Створено {total} кандидата й залишено автоматично, без перегляду.",
       "chosen": "Залишено {kept} із {total} створених кандидатів.",
       "awaiting": "Створено {total} кандидатів, які очікують на порівняння."
+    },
+    "asset": {
+      "loading": "Завантаження файлу…",
+      "loadFailed": "Не вдалося завантажити збережений файл.",
+      "retry": "Спробувати ще раз",
+      "open": "Відкрити",
+      "download": "Зберегти копію",
+      "unknownType": "Збережений файл"
     }
   },
   "sandbox": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.276.0",
+  "version": "0.277.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.41",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.315.0"
+    "@cat-factory/contracts": "0.316.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",