@cat-factory/app 0.300.2 → 0.301.1

package/app/components/panels/inspector/ServiceTestingContext.logic.spec.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest'
+import { rehydratedDraft } from './ServiceTestingContext.logic'
+
+const TYPED = 'Sign in as $DEMO_USER. The seeded tenant is Acme.'
+
+describe('rehydratedDraft', () => {
+  it('follows the board while the operator has typed nothing of their own', () => {
+    // A teammate saves in another tab: the live board event is the only thing that will ever tell
+    // this textarea, so an untouched draft has to take it.
+    const arrives = { draft: '', previous: '', incoming: TYPED, saving: false }
+    expect(rehydratedDraft(arrives)).toBe(TYPED)
+    expect(rehydratedDraft({ ...arrives, draft: 'old prose', previous: 'old prose' })).toBe(TYPED)
+  })
+
+  it('leaves an in-progress edit alone when someone else saves', () => {
+    expect(
+      rehydratedDraft({ draft: TYPED, previous: '', incoming: 'their prose', saving: false }),
+    ).toBe(TYPED)
+  })
+
+  it('keeps unsaved prose through the whole of a REJECTED save', () => {
+    // The sequence the board store produces for a first-time write that fails: the optimistic
+    // patch announces our own text, then the rollback announces the value we started from. The
+    // second one is the dangerous one, because by then the draft matches what the block last said
+    // and the change reads exactly like a teammate's edit. Both land while `saving`.
+    const optimistic = { draft: TYPED, previous: '', incoming: TYPED, saving: true }
+    expect(rehydratedDraft(optimistic)).toBe(TYPED)
+    const rolledBack = { draft: TYPED, previous: TYPED, incoming: '', saving: true }
+    expect(rehydratedDraft(rolledBack)).toBe(TYPED)
+  })
+
+  it('keeps keystrokes typed while a save is in flight', () => {
+    const stillTyping = `${TYPED} Never run the billing flow.`
+    expect(
+      rehydratedDraft({ draft: stillTyping, previous: '', incoming: TYPED, saving: true }),
+    ).toBe(stillTyping)
+  })
+})

package/app/components/panels/inspector/ServiceTestingContext.logic.ts

@@ -0,0 +1,37 @@
+// The pure half of ServiceTestingContext: when a testing context arriving from the board may
+// replace what the operator has typed into the textarea. Extracted for the reason every
+// `*.logic.ts` here is (a decision worth a test should not need a mounted component to reach),
+// and this one is a rule whose failure mode is silent and expensive.
+
+/** The block value moving under the textarea, plus what the textarea currently holds. */
+export interface DraftRehydration {
+  /** What the operator has in the textarea right now. */
+  draft: string
+  /** The persisted value the draft was last in step with (the watcher's previous value). */
+  previous: string
+  /** The persisted value that just arrived. */
+  incoming: string
+  /** Whether THIS panel has a save in flight. */
+  saving: boolean
+}
+
+/**
+ * The draft to hold after the block's persisted testing context moved.
+ *
+ * An UNTOUCHED draft follows the board, so a teammate's edit lands live; a touched one is left
+ * alone. "Untouched" is measured against the value the draft was last in step with rather than
+ * against a dirty flag, because during an edit both are equally "different from what is stored"
+ * and only one of them may be overwritten.
+ *
+ * WHILE THIS PANEL IS SAVING, nothing is taken at all, and that is the case worth the extra state:
+ * the board store patches the block OPTIMISTICALLY and restores the old value if the request
+ * fails, so a rejected save arrives as a value change whose `previous` is our own optimistic write,
+ * which is exactly what an untouched draft looks like. Following it would hand the operator an
+ * emptied textarea, an "update failed" toast, and no copy of what they wrote. Every value change
+ * inside that window is ours (the optimistic write, the server's echo, the rollback), so ignoring
+ * the lot also keeps the keystrokes typed while the request was in flight.
+ */
+export function rehydratedDraft(state: DraftRehydration): string {
+  if (state.saving) return state.draft
+  return state.draft === state.previous ? state.incoming : state.draft
+}

package/app/components/panels/inspector/ServiceTestingContext.vue

@@ -0,0 +1,141 @@
+<script setup lang="ts">
+import { computed, ref, watch } from 'vue'
+import { TESTING_CONTEXT_MAX_LENGTH } from '@cat-factory/contracts'
+import type { Block } from '~/types/domain'
+import InspectorSection from '~/components/panels/inspector/InspectorSection.vue'
+import { rehydratedDraft } from '~/components/panels/inspector/ServiceTestingContext.logic'
+import { showOverrideField } from '~/utils/uiMode'
+
+// Per-service (frame) TESTING CONTEXT: freeform prose about how this service is tested, which
+// the engine injects verbatim into every tester prompt for it: the pipeline testers and the
+// environment dry run's prober alike. It sits beside the sealed test credentials because the
+// two are halves of one answer: the credentials are the material, this is what to do with it.
+//
+// Non-sensitive by contract: it is rendered INTO the prompt, so a real secret belongs one panel
+// up, in the sealed store, and this prose refers to it by variable name. The banner says so.
+//
+// It is a plain block field (like the provisioning config), so it saves through the board store's
+// `updateBlock` rather than a store of its own, and the draft below is what makes it an explicit
+// save instead of a keystroke-per-request.
+const props = defineProps<{ block: Block }>()
+
+const board = useBoardStore()
+const uiMode = useUiModeStore()
+const toast = useToast()
+const { t } = useI18n()
+
+const busy = ref(false)
+const draft = ref(props.block.testingContext ?? '')
+
+// Re-hydrate from the block when the persisted value moves, but never over what the operator has
+// typed (`rehydratedDraft` owns the rule and its spec states each case). The board store patches
+// optimistically and ROLLS BACK on a rejected write, so a failed save arrives here looking exactly
+// like a teammate's edit; taking it would erase the prose the toast is telling the operator to try
+// saving again.
+watch(
+  () => props.block.testingContext ?? '',
+  (incoming, previous) => {
+    draft.value = rehydratedDraft({ draft: draft.value, previous, incoming, saving: busy.value })
+  },
+)
+
+const saved = computed(() => props.block.testingContext ?? '')
+// What a save would SEND, which is what the server would store: the request trims before it caps,
+// so trailing whitespace is neither length spent nor a change worth a request.
+const outgoing = computed(() => draft.value.trim())
+const tooLong = computed(() => outgoing.value.length > TESTING_CONTEXT_MAX_LENGTH)
+const dirty = computed(() => outgoing.value !== saved.value)
+const canSave = computed(() => !busy.value && dirty.value && !tooLong.value)
+
+// Standing per-service configuration, not part of the everyday delivery loop: a service is briefed
+// once and every task then ships without anyone opening this. Absent, every tester prompt is
+// byte-identical to one written before the field existed, which is what makes hiding it honest at
+// the basic tier. `showOverrideField` (not a bare `isAdvanced`) because a service that HAS been
+// briefed must show its prose to whoever opens the inspector: nothing else in the SPA surfaces
+// what the testers are being told, so hiding a filled box would leave a basic-tier user unable to
+// read, correct or clear it. The ROLE axis needs no separate answer: `intake` is capped at basic
+// and never configures the platform, so this reaches the same people the tier bar admits.
+const show = computed(() => showOverrideField(uiMode.isAdvanced, saved.value))
+
+async function save() {
+  busy.value = true
+  try {
+    // `updateBlock` reports its own failure (it rolls back and toasts), so only the success
+    // needs saying here; announcing it unconditionally would claim a save the rollback undid.
+    const persisted = await board.updateBlock(props.block.id, { testingContext: outgoing.value })
+    if (persisted) {
+      toast.add({
+        title: t('inspector.testingContext.savedToast'),
+        icon: 'i-lucide-check',
+        color: 'success',
+      })
+    }
+  } finally {
+    busy.value = false
+  }
+}
+
+function revert() {
+  draft.value = saved.value
+}
+</script>
+
+<template>
+  <InspectorSection
+    v-if="show"
+    :title="t('inspector.testingContext.title')"
+    :hint="t('inspector.testingContext.sectionHint')"
+    data-testid="service-testing-context"
+  >
+    <!-- This text reaches the model in the prompt, so it must never hold a real secret. -->
+    <div
+      class="flex items-start gap-2 rounded-md border border-slate-700 bg-slate-800/40 px-2.5 py-2 text-[11px] leading-snug text-slate-300"
+    >
+      <UIcon name="i-lucide-info" class="mt-0.5 h-4 w-4 shrink-0 text-slate-400" />
+      <span>{{ t('inspector.testingContext.notSecret') }}</span>
+    </div>
+
+    <UTextarea
+      v-model="draft"
+      :rows="8"
+      :placeholder="t('inspector.testingContext.placeholder')"
+      class="w-full"
+      data-testid="testing-context-input"
+    />
+
+    <div class="flex items-center justify-between gap-2">
+      <p class="text-[11px] text-slate-500" :class="{ 'text-error-400': tooLong }">
+        {{
+          t('inspector.testingContext.length', {
+            count: outgoing.length,
+            max: TESTING_CONTEXT_MAX_LENGTH,
+          })
+        }}
+      </p>
+      <div class="flex items-center gap-2">
+        <UButton
+          v-if="dirty"
+          color="neutral"
+          variant="ghost"
+          size="xs"
+          data-testid="testing-context-revert"
+          @click="revert"
+        >
+          {{ t('inspector.testingContext.revert') }}
+        </UButton>
+        <UButton
+          color="primary"
+          variant="soft"
+          size="xs"
+          icon="i-lucide-save"
+          :loading="busy"
+          :disabled="!canSave"
+          data-testid="testing-context-save"
+          @click="save"
+        >
+          {{ t('inspector.testingContext.save') }}
+        </UButton>
+      </div>
+    </div>
+  </InspectorSection>
+</template>

package/app/components/tasks/BugHuntModal.vue

@@ -274,8 +274,10 @@ function loadBoardsFor(next: TaskSourceKind | undefined) {
 async function runHunt() {
   const input = request.value
   if (!source.value || !input) return
-  const ok = await hunt.hunt(source.value, input)
-  if (!ok && !huntNeedsRepo.value) {
+  // Only a real failure is reported. A cancelled credential prompt leaves nothing to say, and
+  // `repo_not_linked` is worded by the panel itself beside the scope it invalidates.
+  const attempt = await hunt.hunt(source.value, input)
+  if (attempt === 'failed' && !huntNeedsRepo.value) {
     toast.add({
       title: t('bugHunt.huntFailed'),
       description: refusalText(hunt.huntErrorReason, hunt.huntError) ?? undefined,

package/app/composables/api/assistant.ts

@@ -3,7 +3,7 @@ import type { AssistantAnswer } from '~/types/domain'
 import type { ApiContext } from './context'
 
 /** In-app assistant: what it can do here, and one prompt-to-action turn. */
-export function assistantApi({ send, ws }: ApiContext) {
+export function assistantApi({ send, sendWith, ws, pwHeaders }: ApiContext) {
   return {
     // Whether a model is wired and which actions this deployment offers. Read before the prompt
     // box is shown, so an unconfigured deployment says so instead of failing on submit. `signal`
@@ -14,8 +14,12 @@ export function assistantApi({ send, ws }: ApiContext) {
 
     // Run one turn. A live model call plus a board write, so it can take a couple of seconds:
     // the modal shows progress and the outcome is rendered from the returned data.
-    runAssistantTurn: (workspaceId: string, prompt: string) =>
-      send(runAssistantTurnContract, {
+    //
+    // Carries the personal password header, like a run start does, because the turn resolves the
+    // workspace's own preset: a workspace pinned to an individual-usage subscription runs this
+    // surface on it, and without the header it could only ever fall back to another model.
+    runAssistantTurn: (workspaceId: string, prompt: string, password?: string) =>
+      sendWith(pwHeaders(password), runAssistantTurnContract, {
         pathPrefix: ws(workspaceId),
         body: { kind: 'prompt', prompt },
       }),

package/app/composables/api/bugHunt.ts

@@ -16,8 +16,16 @@ export function bugHuntApi({ send, sendWith, ws, pwHeaders }: ApiContext) {
 
     // Scan the board for open, unassigned bugs and rank them by impact vs complexity. A live
     // external call plus a model call, so it can take a while — the modal shows progress.
-    runBugHunt: (workspaceId: string, source: TaskSourceKind, body: RunBugHuntInput) =>
-      send(runBugHuntContract, {
+    // Carries the personal password for the same reason `adoptBugHuntCandidate` below does: the
+    // RANKING is a model call resolved under the workspace's preset, so a subscription-pinned
+    // workspace needs the credential here and not only at adoption.
+    runBugHunt: (
+      workspaceId: string,
+      source: TaskSourceKind,
+      body: RunBugHuntInput,
+      password?: string,
+    ) =>
+      sendWith(pwHeaders(password), runBugHuntContract, {
         pathPrefix: ws(workspaceId),
         pathParams: { source },
         body,

package/app/modular/panels/inspector.logic.spec.ts

@@ -39,6 +39,7 @@ describe('inspector panel group', () => {
       'service-connections',
       'service-test-config',
       'service-test-secrets',
+      'service-testing-context',
       'service-fragments',
       'service-release-health',
       'service-validation-checks',
@@ -58,6 +59,7 @@ describe('inspector panel group', () => {
       'container-summary',
       'service-test-config',
       'service-test-secrets',
+      'service-testing-context',
       'service-fragments',
       'service-release-health',
       'service-validation-checks',
@@ -70,6 +72,7 @@ describe('inspector panel group', () => {
       'frontend-config',
       'service-test-config',
       'service-test-secrets',
+      'service-testing-context',
       'service-fragments',
       'service-release-health',
       'service-validation-checks',

package/app/modular/panels/inspector.logic.ts

@@ -53,6 +53,7 @@ export const INSPECTOR_PANEL_IDS = [
   'service-connections',
   'service-test-config',
   'service-test-secrets',
+  'service-testing-context',
   'service-fragments',
   'service-release-health',
   'service-validation-checks',
@@ -146,6 +147,10 @@ export const INSPECTOR_PANEL_SPECS: readonly InspectorPanelSpec[] = [
   { id: 'service-connections', order: 130, when: (b) => isFrame(b) && b.type === 'service' },
   { id: 'service-test-config', order: 140, when: isDeployableFrame },
   { id: 'service-test-secrets', order: 150, when: isDeployableFrame },
+  // Immediately after the credentials: the prose that says what to DO with them, and the other
+  // half of what a tester is handed about this service. Same gate for the same reason (a doc
+  // repo runs no tester at all).
+  { id: 'service-testing-context', order: 155, when: isDeployableFrame },
   { id: 'service-fragments', order: 160, when: isFrame },
   { id: 'service-release-health', order: 170, when: isDeployableFrame },
   // Pre-PR validation checks: the commands the harness runs before opening this service's PRs.

package/app/modular/panels/inspector.ts

@@ -28,6 +28,7 @@ import FrontendConfig from '~/components/panels/inspector/FrontendConfig.vue'
 import ServiceConnections from '~/components/panels/inspector/ServiceConnections.vue'
 import ServiceTestConfig from '~/components/panels/inspector/ServiceTestConfig.vue'
 import ServiceTestSecrets from '~/components/panels/inspector/ServiceTestSecrets.vue'
+import ServiceTestingContext from '~/components/panels/inspector/ServiceTestingContext.vue'
 import ServiceFragments from '~/components/panels/inspector/ServiceFragments.vue'
 import ServiceReleaseHealthConfig from '~/components/panels/inspector/ServiceReleaseHealthConfig.vue'
 import ServiceValidationConfig from '~/components/panels/inspector/ServiceValidationConfig.vue'
@@ -83,6 +84,7 @@ const COMPONENTS: Record<InspectorPanelId, Component> = {
   'service-connections': ServiceConnections,
   'service-test-config': ServiceTestConfig,
   'service-test-secrets': ServiceTestSecrets,
+  'service-testing-context': ServiceTestingContext,
   'service-fragments': ServiceFragments,
   'service-release-health': ServiceReleaseHealthConfig,
   'service-validation-checks': ServiceValidationConfig,

package/app/stores/assistant.spec.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
 import { useAssistantStore } from '~/stores/assistant'
 import { useWorkspaceStore } from '~/stores/workspace'
+import { usePersonalSubscriptionsStore } from '~/stores/personalSubscriptions'
 import { ApiError } from '~/composables/api/errors'
 import type { AssistantCapability } from '~/types/domain'
 
@@ -181,3 +182,53 @@ describe('assistant store: the capability read deadline', () => {
     expect(store.capabilityRead).toBe('error')
   })
 })
+
+// The credential half of a turn: a workspace whose preset pins an individual-usage subscription
+// runs this surface on it, which means the turn has to be able to ASK for the password and to
+// survive being refused one.
+describe('assistant store: the personal-credential flow', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  function stubTurn(
+    withCredential: (action: (password?: string) => Promise<void>) => Promise<boolean>,
+  ) {
+    const calls: (string | undefined)[] = []
+    vi.stubGlobal('useApi', () => ({
+      getAssistantCapability: async () => ({ available: true, actions: ['add-service-from-repo'] }),
+      runAssistantTurn: async (_ws: string, _prompt: string, password?: string) => {
+        calls.push(password)
+        return { outcome: { status: 'declined', reason: 'no_matching_action' }, model: null }
+      },
+    }))
+    usePersonalSubscriptionsStore().withCredential = withCredential as unknown as ReturnType<
+      typeof usePersonalSubscriptionsStore
+    >['withCredential']
+    return { store: useAssistantStore(), calls }
+  }
+
+  it('carries the password the credential flow supplies into the turn', async () => {
+    // Without it a workspace pinned to a personal subscription could only ever be answered by
+    // some other model, which is the failure this whole path exists to close.
+    const { store, calls } = stubTurn(async (action) => {
+      await action('correct horse')
+      return true
+    })
+
+    const turn = await store.run('add the payments repo')
+
+    expect(calls).toEqual(['correct horse'])
+    expect(turn).not.toBeNull()
+  })
+
+  it('answers null when the person cancels the password prompt', async () => {
+    // A cancel is not a failed turn and not a declined one: nothing ran, so there is no outcome
+    // to render. Reporting it as either would put a refusal on screen that nobody caused.
+    const { store, calls } = stubTurn(async () => false)
+
+    expect(await store.run('add the payments repo')).toBeNull()
+    expect(calls).toEqual([])
+    expect(store.turn).toBeNull()
+  })
+})

package/app/stores/assistant.ts

@@ -3,6 +3,7 @@ import { computed, ref } from 'vue'
 import type { AssistantAnswer, AssistantCapability, AssistantTurn } from '~/types/domain'
 import type { LoadState } from '~/types/load-state'
 import { useWorkspaceStore } from '~/stores/workspace'
+import { usePersonalSubscriptionsStore } from '~/stores/personalSubscriptions'
 
 /**
  * How long the capability read waits before it counts as failed.
@@ -99,10 +100,28 @@ export const useAssistantStore = defineStore('assistant', () => {
 
   /**
    * Run one turn. Throws on a refusal so the caller can hand it to the error funnel; the three
-   * outcomes (performed / needs_input / declined) come back as the resolved value.
+   * outcomes (performed / needs_input / declined) come back as the resolved value, and `null`
+   * when the person cancelled the credential prompt.
    */
-  async function run(prompt: string): Promise<AssistantTurn> {
-    return record(() => api.runAssistantTurn(workspace.requireId(), prompt))
+  async function run(prompt: string): Promise<AssistantTurn | null> {
+    // Through the credential flow, exactly as a run start goes: the turn resolves the workspace's
+    // OWN preset, so on a workspace pinned to an individual-usage subscription the first turn 428s,
+    // the modal collects the password, and it rides transparently from the cache after that.
+    //
+    // `null` for a CANCELLED prompt, the shape every gated surface here uses. A cancel is not a
+    // failed turn and not a declined one either: nothing ran, so there is no outcome to render and
+    // nothing to report. `record` never runs, so the kept `turn` is whatever it already was, which
+    // for the modal is nothing: editing the prompt cleared it before submit.
+    //
+    // The completed turn is captured in a local of its OWN name rather than read back off the
+    // store's `turn` ref, which this would otherwise shadow: two bindings spelled the same in one
+    // function is how a later edit writes to the wrong one with nothing failing.
+    const personal = usePersonalSubscriptionsStore()
+    let completed: AssistantTurn | null = null
+    const ran = await personal.withCredential(async (password) => {
+      completed = await record(() => api.runAssistantTurn(workspace.requireId(), prompt, password))
+    })
+    return ran ? completed : null
   }
 
   /**

package/app/stores/bugHunt.spec.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { useBugHuntStore } from '~/stores/bugHunt'
 import { useWorkspaceStore } from '~/stores/workspace'
+import { usePersonalSubscriptionsStore } from '~/stores/personalSubscriptions'
 import { ApiError } from '~/composables/api/errors'
 import type { BugHuntResult, TaskSourceKind, TrackerBoardsView } from '~/types/domain'
 
@@ -181,7 +182,7 @@ describe('bug hunt store — scan failures', () => {
     const { store, serveHunt } = stubApi()
     serveHunt(() => Promise.reject(apiError(422, 'validation', { reason: 'repo_not_linked' })))
 
-    expect(await store.hunt('github', SCAN)).toBe(false)
+    expect(await store.hunt('github', SCAN)).toBe('failed')
 
     expect(store.huntErrorReason).toBe('repo_not_linked')
     expect(store.huntError).toBeTruthy()
@@ -192,7 +193,7 @@ describe('bug hunt store — scan failures', () => {
     const { store, serveHunt } = stubApi()
     serveHunt(() => Promise.reject(apiError(502, 'upstream')))
 
-    expect(await store.hunt('jira', { containerId: 'blk_auth', board: 'PROJ' })).toBe(false)
+    expect(await store.hunt('jira', { containerId: 'blk_auth', board: 'PROJ' })).toBe('failed')
 
     expect(store.huntErrorReason).toBeNull()
     expect(store.huntError).toBeTruthy()
@@ -204,7 +205,7 @@ describe('bug hunt store — scan failures', () => {
     await store.hunt('github', SCAN)
 
     serveHunt(() => Promise.resolve(huntResult()))
-    expect(await store.hunt('github', SCAN)).toBe(true)
+    expect(await store.hunt('github', SCAN)).toBe('ran')
 
     expect(store.huntError).toBeNull()
     expect(store.huntErrorReason).toBeNull()
@@ -222,3 +223,28 @@ describe('bug hunt store — scan failures', () => {
     expect(store.huntError).toBeNull()
   })
 })
+
+describe('bug hunt store: a dismissed credential prompt', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('reports `cancelled` and drops the ranking the previous board left', async () => {
+    // The scan needs the personal password on a subscription-pinned workspace, so the prompt can
+    // be cancelled. Nothing ran: reporting that as a failure raises an error toast with no
+    // description for an action the person themselves called off, and leaving the earlier result
+    // mounted would show one board's candidates under another board's selection.
+    const { store } = stubApi()
+    expect(await store.hunt('github', SCAN)).toBe('ran')
+    expect(store.result).not.toBeNull()
+
+    usePersonalSubscriptionsStore().withCredential = (async () => false) as unknown as ReturnType<
+      typeof usePersonalSubscriptionsStore
+    >['withCredential']
+
+    expect(await store.hunt('github', SCAN)).toBe('cancelled')
+    expect(store.result).toBeNull()
+    expect(store.huntError).toBeNull()
+    expect(store.huntErrorReason).toBeNull()
+  })
+})

package/app/stores/bugHunt.ts

@@ -5,6 +5,12 @@ import { apiErrorReason } from '~/composables/api/errors'
 import { useWorkspaceStore } from '~/stores/workspace'
 import { usePersonalSubscriptionsStore } from '~/stores/personalSubscriptions'
 
+/**
+ * What one attempt did. `cancelled` is distinct from `failed` because the surface reports a
+ * failure: a dismissed credential prompt is the person's own decision, not an outcome to toast.
+ */
+export type BugHuntAttempt = 'ran' | 'cancelled' | 'failed'
+
 /**
  * Bug-hunt state: the boards of the tracker being browsed, the last hunt's ranked candidates,
  * and the actions behind the three steps (list boards → run the hunt → adopt one candidate).
@@ -95,19 +101,36 @@ export const useBugHuntStore = defineStore('bugHunt', () => {
     boardsLoading.value = false
   }
 
-  /** Run a hunt and keep its ranked result. Returns false when the scan itself failed. */
-  async function hunt(source: TaskSourceKind, input: RunBugHuntInput): Promise<boolean> {
+  /**
+   * Run a hunt and keep its ranked result.
+   *
+   * Three outcomes, not two, because the caller reports a failure and only a failure. `cancelled`
+   * is a hunt that never ran: the person dismissed the credential prompt (or the prompt's own
+   * retry failed and the credential modal already said so), so there is nothing to tell them that
+   * they did not just do. Collapsing it into `failed` is an error toast for an action they
+   * cancelled, with no description to put in it.
+   */
+  async function hunt(source: TaskSourceKind, input: RunBugHuntInput): Promise<BugHuntAttempt> {
     hunting.value = true
     huntError.value = null
     huntErrorReason.value = null
+    // A new scan supersedes whatever is on screen the moment it starts. Clearing HERE rather than
+    // on each way out is what keeps a cancelled prompt from leaving the previous board's ranking
+    // under the current selection, where adopting one would file a task against the wrong board.
+    result.value = null
     try {
-      result.value = await api.runBugHunt(workspace.requireId(), source, input)
-      return true
+      // Gated like the adoption below, and for the reason the ranking is the model call: on a
+      // workspace pinned to an individual-usage subscription the scan needs the credential HERE,
+      // not only when a candidate is adopted.
+      const personal = usePersonalSubscriptionsStore()
+      const ran = await personal.withCredential(async (password) => {
+        result.value = await api.runBugHunt(workspace.requireId(), source, input, password)
+      })
+      return ran ? 'ran' : 'cancelled'
     } catch (e) {
-      result.value = null
       huntError.value = e instanceof Error ? e.message : String(e)
       huntErrorReason.value = apiErrorReason(e)
-      return false
+      return 'failed'
     } finally {
       hunting.value = false
     }

package/i18n/locales/de.json

@@ -1596,6 +1596,16 @@
       "configNoun": "die sensiblen Test-Anmeldedaten",
       "duplicateKey": "Jeder Variablenname muss eindeutig sein."
     },
+    "testingContext": {
+      "title": "Testkontext",
+      "sectionHint": "Freitext dazu, wie dieser Service getestet wird: welche Abläufe wichtig sind, welche Testkonten es gibt und wie man sich damit anmeldet, was die eingespielten Daten bedeuten, was unangetastet bleiben soll. Jeder Tester-Lauf für diesen Service bekommt diesen Text wörtlich, der Probelauf der Umgebung ebenso.",
+      "notSecret": "Dieser Text geht unverändert in den Prompt des Testers. Echte Geheimnisse gehören nicht hierher: Trage sie oben unter „Test-Anmeldedaten“ ein und verweise hier nur über den Variablennamen darauf.",
+      "placeholder": "z. B. als $DEMO_USER anmelden; der eingespielte Mandant ist Acme mit drei Projekten; den Abrechnungsablauf nie ausführen, er belastet eine echte Karte.",
+      "length": "{count} von {max} Zeichen",
+      "save": "Testkontext speichern",
+      "revert": "Änderungen verwerfen",
+      "savedToast": "Testkontext gespeichert"
+    },
     "testConfig": {
       "title": "Testinfrastruktur",
       "hint": "Wie eine Testumgebung für diesen Service aufgesetzt wird, wenn eine Pipeline ihn ausführen muss: keine Infrastruktur, eine Docker-Compose-Datei, Kubernetes-Manifeste oder ein benutzerdefinierter Manifesttyp.",

package/i18n/locales/en.json

@@ -1147,6 +1147,22 @@
       "configNoun": "the sensitive test credentials",
       "duplicateKey": "Each variable name must be unique."
     },
+    "testingContext": {
+      "title": "Testing context",
+      "@title": {
+        "description": "Section header for the freeform notes a team writes about how their service should be tested. 'Context' here means background information for whoever tests it, not a programming context object."
+      },
+      "sectionHint": "Freeform notes about how this service is tested: which flows matter, which test accounts exist and how to sign in as one, what the seeded data means, what to leave alone. Every tester run for this service is handed this text word for word, and so is the environment dry run.",
+      "notSecret": "This text goes straight into the tester's prompt, so keep real secrets out of it. Put a secret in Test credentials above and refer to it here by its variable name.",
+      "placeholder": "e.g. sign in as $DEMO_USER; the seeded tenant is Acme with three projects; never run the billing flow, it charges a real card.",
+      "length": "{count} of {max} characters",
+      "@length": {
+        "description": "Character counter under a long text box. {count} is how many characters are typed so far, {max} the limit."
+      },
+      "save": "Save testing context",
+      "revert": "Discard changes",
+      "savedToast": "Testing context saved"
+    },
     "testConfig": {
       "title": "Test infrastructure",
       "hint": "How a test environment is stood up for this service when a pipeline needs to run it: no infrastructure, a Docker Compose file, Kubernetes manifests, or a custom manifest type.",

package/i18n/locales/es.json

@@ -1051,6 +1051,16 @@
       "configNoun": "las credenciales de prueba sensibles",
       "duplicateKey": "Cada nombre de variable debe ser único."
     },
+    "testingContext": {
+      "title": "Contexto de pruebas",
+      "sectionHint": "Notas libres sobre cómo se prueba este servicio: qué flujos importan, qué cuentas de prueba existen y cómo iniciar sesión con ellas, qué significan los datos precargados y qué no hay que tocar. Cada ejecución del Tester para este servicio recibe este texto tal cual, igual que la prueba en seco del entorno.",
+      "notSecret": "Este texto se envía tal cual al prompt del Tester, así que no pongas secretos reales aquí. Guárdalos arriba, en «Credenciales de prueba», y menciónalos aquí solo por el nombre de la variable.",
+      "placeholder": "p. ej. inicia sesión como $DEMO_USER; el inquilino precargado es Acme con tres proyectos; nunca ejecutes el flujo de facturación, cobra a una tarjeta real.",
+      "length": "{count} de {max} caracteres",
+      "save": "Guardar contexto de pruebas",
+      "revert": "Descartar cambios",
+      "savedToast": "Contexto de pruebas guardado"
+    },
     "testConfig": {
       "title": "Infraestructura de pruebas",
       "hint": "Cómo se levanta un entorno de prueba para este servicio cuando un pipeline necesita ejecutarlo: sin infraestructura, un archivo de Docker Compose, manifiestos de Kubernetes o un tipo de manifiesto personalizado.",

package/i18n/locales/fr.json

@@ -1051,6 +1051,16 @@
       "configNoun": "les identifiants de test sensibles",
       "duplicateKey": "Chaque nom de variable doit être unique."
     },
+    "testingContext": {
+      "title": "Contexte de test",
+      "sectionHint": "Notes libres sur la façon de tester ce service : quels parcours comptent, quels comptes de test existent et comment s'y connecter, ce que signifient les données préchargées, ce qu'il ne faut pas toucher. Chaque exécution du testeur pour ce service reçoit ce texte mot pour mot, tout comme l'essai à blanc de l'environnement.",
+      "notSecret": "Ce texte part tel quel dans l'invite du testeur : n'y mettez pas de véritables secrets. Saisissez-les au-dessus, dans « Identifiants de test », et n'y faites référence ici que par le nom de la variable.",
+      "placeholder": "ex. connectez-vous en tant que $DEMO_USER ; le locataire préchargé est Acme avec trois projets ; ne lancez jamais le parcours de facturation, il débite une vraie carte.",
+      "length": "{count} sur {max} caractères",
+      "save": "Enregistrer le contexte de test",
+      "revert": "Annuler les modifications",
+      "savedToast": "Contexte de test enregistré"
+    },
     "testConfig": {
       "title": "Infrastructure de test",
       "hint": "Comment un environnement de test est mis en place pour ce service quand un pipeline doit l'exécuter : sans infrastructure, un fichier Docker Compose, des manifestes Kubernetes ou un type de manifeste personnalisé.",

package/i18n/locales/he.json

@@ -1051,6 +1051,16 @@
       "configNoun": "פרטי הגישה הרגישים לבדיקה",
       "duplicateKey": "כל שם משתנה חייב להיות ייחודי."
     },
+    "testingContext": {
+      "title": "הקשר לבדיקות",
+      "sectionHint": "טקסט חופשי על אופן הבדיקה של השירות הזה: אילו תהליכים חשובים, אילו חשבונות בדיקה קיימים וכיצד מתחברים איתם, מה המשמעות של הנתונים שנטענו ובמה אסור לגעת. כל הרצת בודק עבור השירות הזה מקבלת את הטקסט הזה מילה במילה, וכך גם הרצת היבש של הסביבה.",
+      "notSecret": "הטקסט הזה נכנס כמו שהוא לפרומפט של הבודק, ולכן אין לכתוב בו סודות אמיתיים. שמרו אותם למעלה, תחת «פרטי גישה לבדיקה», והזכירו אותם כאן רק בשם המשתנה.",
+      "placeholder": "לדוגמה: התחברו כ-$DEMO_USER; הדייר שנטען הוא Acme עם שלושה פרויקטים; לעולם אל תריצו את תהליך החיוב, הוא מחייב כרטיס אמיתי.",
+      "length": "{count} מתוך {max} תווים",
+      "save": "שמירת ההקשר לבדיקות",
+      "revert": "ביטול השינויים",
+      "savedToast": "ההקשר לבדיקות נשמר"
+    },
     "testConfig": {
       "title": "תשתית בדיקות",
       "hint": "כיצד מוקמת סביבת בדיקה לשירות זה כאשר פייפליין צריך להריץ אותו: ללא תשתית, קובץ Docker Compose, מניפסטים של Kubernetes או סוג מניפסט מותאם אישית.",

package/i18n/locales/it.json

@@ -1596,6 +1596,16 @@
       "configNoun": "le credenziali di test sensibili",
       "duplicateKey": "Ogni nome di variabile deve essere univoco."
     },
+    "testingContext": {
+      "title": "Contesto di test",
+      "sectionHint": "Note libere su come si testa questo servizio: quali flussi contano, quali account di prova esistono e come accedervi, che cosa significano i dati precaricati, che cosa non va toccato. Ogni esecuzione del Tester per questo servizio riceve questo testo alla lettera, così come la prova a vuoto dell'ambiente.",
+      "notSecret": "Questo testo finisce così com'è nel prompt del Tester, quindi non inserirci segreti veri. Mettili sopra, in «Credenziali di test», e qui richiamali solo con il nome della variabile.",
+      "placeholder": "es. accedi come $DEMO_USER; il tenant precaricato è Acme con tre progetti; non eseguire mai il flusso di fatturazione, addebita una carta vera.",
+      "length": "{count} di {max} caratteri",
+      "save": "Salva il contesto di test",
+      "revert": "Annulla le modifiche",
+      "savedToast": "Contesto di test salvato"
+    },
     "testConfig": {
       "title": "Infrastruttura di test",
       "hint": "Come viene predisposto un ambiente di test per questo servizio quando una pipeline deve eseguirlo: nessuna infrastruttura, un file Docker Compose, manifest Kubernetes, o un tipo di manifest personalizzato.",

package/i18n/locales/ja.json

@@ -1051,6 +1051,16 @@
       "configNoun": "機密のテスト用認証情報",
       "duplicateKey": "変数名はそれぞれ一意である必要があります。"
     },
+    "testingContext": {
+      "title": "テストの前提情報",
+      "sectionHint": "このサービスをどうテストするかについての自由記述です。重要なフロー、用意されているテストアカウントとそのログイン方法、投入済みデータの意味、触れてはいけない箇所などを書きます。このサービスのテスターは毎回この文章をそのまま渡され、環境のドライランでも同じ文章が使われます。",
+      "notSecret": "この文章はそのままテスターのプロンプトに入ります。本物の秘密情報は書かないでください。秘密情報は上の「テスト用認証情報」に登録し、ここでは変数名だけで参照してください。",
+      "placeholder": "例: $DEMO_USER でログインする。投入済みのテナントは Acme で、プロジェクトが 3 件ある。課金フローは実際のカードに請求されるので絶対に実行しない。",
+      "length": "{max} 文字中 {count} 文字",
+      "save": "前提情報を保存",
+      "revert": "変更を破棄",
+      "savedToast": "テストの前提情報を保存しました"
+    },
     "testConfig": {
       "title": "テストインフラ",
       "hint": "パイプラインがこのサービスを実行する必要があるときに、テスト環境をどう立ち上げるか: インフラなし、Docker Compose ファイル、Kubernetes マニフェスト、またはカスタムマニフェストタイプ。",

package/i18n/locales/pl.json

@@ -1051,6 +1051,16 @@
       "configNoun": "wrażliwe poświadczenia testowe",
       "duplicateKey": "Każda nazwa zmiennej musi być unikalna."
     },
+    "testingContext": {
+      "title": "Kontekst testowania",
+      "sectionHint": "Dowolne notatki o tym, jak testuje się tę usługę: które przepływy są ważne, jakie konta testowe istnieją i jak się na nie zalogować, co oznaczają wgrane dane i czego nie ruszać. Każde uruchomienie Testera dla tej usługi dostaje ten tekst dosłownie, tak samo jak próbne uruchomienie środowiska.",
+      "notSecret": "Ten tekst trafia wprost do promptu Testera, więc nie wpisuj tu prawdziwych sekretów. Zapisz je wyżej, w „Poświadczeniach testowych”, i odwołuj się do nich tutaj tylko przez nazwę zmiennej.",
+      "placeholder": "np. zaloguj się jako $DEMO_USER; wgrany najemca to Acme z trzema projektami; nigdy nie uruchamiaj przepływu płatności, obciąża prawdziwą kartę.",
+      "length": "{count} z {max} znaków",
+      "save": "Zapisz kontekst testowania",
+      "revert": "Odrzuć zmiany",
+      "savedToast": "Zapisano kontekst testowania"
+    },
     "testConfig": {
       "title": "Infrastruktura testowa",
       "hint": "Jak stawiane jest środowisko testowe dla tej usługi, gdy potok musi ją uruchomić: bez infrastruktury, plik Docker Compose, manifesty Kubernetes lub niestandardowy typ manifestu.",

package/i18n/locales/tr.json

@@ -1051,6 +1051,16 @@
       "configNoun": "hassas test kimlik bilgileri",
       "duplicateKey": "Her değişken adı benzersiz olmalıdır."
     },
+    "testingContext": {
+      "title": "Test bağlamı",
+      "sectionHint": "Bu servisin nasıl test edildiğine dair serbest notlar: hangi akışlar önemli, hangi test hesapları var ve bunlarla nasıl oturum açılır, yüklü veriler ne anlama geliyor, neye dokunulmamalı. Bu servis için her Test Edici çalışması bu metni harfi harfine alır; ortamın deneme çalışması da öyle.",
+      "notSecret": "Bu metin doğrudan Test Edici'nin istemine girer, bu yüzden gerçek sırları buraya yazmayın. Onları yukarıdaki «Test kimlik bilgileri» bölümüne kaydedin ve burada yalnızca değişken adıyla anın.",
+      "placeholder": "ör. $DEMO_USER olarak oturum açın; yüklü kiracı üç projeli Acme'dir; faturalama akışını asla çalıştırmayın, gerçek bir kartı borçlandırır.",
+      "length": "{count} / {max} karakter",
+      "save": "Test bağlamını kaydet",
+      "revert": "Değişiklikleri geri al",
+      "savedToast": "Test bağlamı kaydedildi"
+    },
     "testConfig": {
       "title": "Test altyapısı",
       "hint": "Bir pipeline bu servisi çalıştırmak istediğinde test ortamının nasıl kurulacağı: altyapısız, bir Docker Compose dosyası, Kubernetes manifestoları veya özel bir manifest türü.",

package/i18n/locales/uk.json

@@ -1051,6 +1051,16 @@
       "configNoun": "конфіденційні тестові облікові дані",
       "duplicateKey": "Кожна назва змінної має бути унікальною."
     },
+    "testingContext": {
+      "title": "Контекст тестування",
+      "sectionHint": "Довільні нотатки про те, як тестують цю службу: які сценарії важливі, які тестові облікові записи існують і як під ними увійти, що означають наповнені дані та чого не чіпати. Кожен запуск Тестувальника для цієї служби отримує цей текст дослівно, так само як і пробний запуск середовища.",
+      "notSecret": "Цей текст потрапляє просто в підказку Тестувальника, тож не пишіть тут справжніх секретів. Зберігайте їх вище, у «Тестових облікових даних», а тут посилайтеся лише на назву змінної.",
+      "placeholder": "напр. увійдіть як $DEMO_USER; наповнений орендар: Acme з трьома проєктами; ніколи не запускайте сценарій оплати, він списує кошти зі справжньої картки.",
+      "length": "{count} з {max} символів",
+      "save": "Зберегти контекст тестування",
+      "revert": "Скасувати зміни",
+      "savedToast": "Контекст тестування збережено"
+    },
     "testConfig": {
       "title": "Тестова інфраструктура",
       "hint": "Як розгортається тестове середовище для цього сервісу, коли конвеєру потрібно його запустити: без інфраструктури, файл Docker Compose, маніфести Kubernetes або власний тип маніфесту.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.300.2",
+  "version": "0.301.1",
   "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",
@@ -18,7 +18,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@cat-factory/contracts": "0.351.1",
+    "@cat-factory/contracts": "0.353.0",
     "@modular-frontend/core": "0.6.0",
     "@modular-vue/core": "^1.5.0",
     "@modular-vue/journeys": "^1.4.0",