@cat-factory/app 0.301.0 → 0.301.1

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.301.0",
+  "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.352.0",
+    "@cat-factory/contracts": "0.353.0",
     "@modular-frontend/core": "0.6.0",
     "@modular-vue/core": "^1.5.0",
     "@modular-vue/journeys": "^1.4.0",