@cat-factory/app 0.227.0 → 0.228.1

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

@@ -190,6 +190,18 @@ function rootUnderDirectory(directory: string | null | undefined, path: string):
   return segs.join('/')
 }
 
+// The repo + service subdirectory backing this frame (the manifest prefills, the fixer
+// run, and the compose-file browser all root paths under it). A monorepo service isn't
+// on the `github_repos` blockId link (that stays null), so fall back to the service
+// catalog mapping, which carries the repo + directory.
+const repoContext = computed<{ githubId: number; directory?: string | null } | undefined>(() => {
+  if (props.repo) return props.repo
+  const svc = services.serviceByFrameBlock[props.block.id]
+  if (svc?.repoGithubId != null) return { githubId: svc.repoGithubId, directory: svc.directory }
+  const r = github.repoForBlock(props.block.id)
+  return r ? { githubId: r.githubId } : undefined
+})
+
 function setCustomManifestId(value: string) {
   // Prefill the manifest path with the selected type's default, rooted under the service subtree
   // (repo-root-relative, editable afterwards) so a monorepo service targets the right location
@@ -366,17 +378,6 @@ async function stopEnvTest() {
 // ephemeral-environment provisioner, not commonly tuned — keep them collapsed by default.
 const showProvisioning = ref(false)
 
-// The repo + service subdirectory backing this frame, for the compose-file browser.
-// A monorepo service isn't on the `github_repos` blockId link (that stays null), so
-// fall back to the service catalog mapping, which carries the repo + directory.
-const repoContext = computed<{ githubId: number; directory?: string | null } | undefined>(() => {
-  if (props.repo) return props.repo
-  const svc = services.serviceByFrameBlock[props.block.id]
-  if (svc?.repoGithubId != null) return { githubId: svc.repoGithubId, directory: svc.directory }
-  const r = github.repoForBlock(props.block.id)
-  return r ? { githubId: r.githubId } : undefined
-})
-
 // Repo-path picker, shared by the compose file (`docker compose -f <path>`) and the
 // kubernetes colocated manifests path. The stored path is relative to the repo root (the
 // browser starts inside the service's subdirectory for convenience).

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

@@ -19,6 +19,7 @@ import type { ChangeClass, ReviewEffort } from '~/types/merge'
 import MergeEffortChips from '~/components/merge/MergeEffortChips.vue'
 import InputGateNotice from '~/components/inputGate/InputGateNotice.vue'
 import { inputGateNoticeFor } from '~/utils/inputGate'
+import { composeRunOutcome, hasOutcomeToShow } from '~/utils/runOutcome'
 
 const props = defineProps<{ block: Block }>()
 
@@ -55,6 +56,13 @@ const instance = computed(() => execution.getInstance(props.block.executionId))
 // is that nothing will merge, and WHY is answered by the run's own notes and the merge decision.
 const sandboxed = computed(() => isDryRun(instance.value?.mode))
 
+// A failed pipeline run surfaces the shared failure banner + retry — the
+// execution failure surface that the old `pr_ready` flip used to hide.
+const failedRun = computed(() => {
+  const run = agentRuns.byBlock[props.block.id]
+  return run && run.status === 'failed' ? run : null
+})
+
 // Nothing to show yet: no run, no failed run, no PR, and not awaiting a merge — render an
 // empty state instead of a blank gap so the section reads as "no runs yet" rather than broken.
 const isEmpty = computed(
@@ -76,17 +84,26 @@ const runFailed = computed(() => instance.value?.status === 'failed')
  */
 const inputGateNotice = computed(() => inputGateNoticeFor(instance.value))
 
-// A failed pipeline run surfaces the shared failure banner + retry — the
-// execution failure surface that the old `pr_ready` flip used to hide.
-const failedRun = computed(() => {
-  const run = agentRuns.byBlock[props.block.id]
-  return run && run.status === 'failed' ? run : null
-})
-
 // Failures from prior attempts, preserved across retries — shown regardless of the run's
 // CURRENT status, so the error trail stays viewable after a restart clears the top banner.
 const failureHistory = computed(() => agentRuns.byBlock[props.block.id]?.failureHistory ?? [])
 
+/**
+ * Whether this task has a result worth reading in product terms: a pull request, or a step that
+ * recorded evidence. Asked of the shared reduction rather than re-derived here, so the panel and
+ * the board card can never disagree about which runs have an outcome to open.
+ *
+ * The spec is deliberately not loaded for this check: it only ever adds TITLES to requirement
+ * rows, never sections, so nothing about whether there is something to show depends on it. The
+ * window loads it on open.
+ */
+const outcomeReadable = computed(() =>
+  hasOutcomeToShow(composeRunOutcome({ block: props.block, instance: instance.value ?? null })),
+)
+function openOutcome() {
+  ui.openOutcome(props.block.id, instance.value?.id ?? null)
+}
+
 const pr = computed(() => props.block.pullRequest)
 /** A PR is merged once the block is `done`; otherwise it is open awaiting merge. */
 const prMerged = computed(() => props.block.status === 'done')
@@ -605,6 +622,22 @@ async function mergePr() {
     <!-- error trail of prior attempts (survives a retry/restart that cleared the banner) -->
     <AgentFailureHistory :failures="failureHistory" />
 
+    <!-- Read the result: the outcome summary is the way in, and the pull request below is the
+         way to the diff. Offered whenever there is evidence or a PR to read, which includes a
+         merged task whose run instance is long gone. -->
+    <UButton
+      v-if="outcomeReadable"
+      color="primary"
+      variant="soft"
+      size="sm"
+      icon="i-lucide-clipboard-check"
+      block
+      data-testid="inspector-open-outcome"
+      @click="openOutcome"
+    >
+      {{ t('inspector.execution.readOutcome') }}
+    </UButton>
+
     <!-- Open PR: link straight to it on GitHub -->
     <div v-if="pr" class="space-y-2">
       <span class="text-[11px] font-semibold uppercase tracking-wide text-slate-400">

package/app/components/pipeline/PipelineProgress.vue

@@ -160,6 +160,11 @@ const STATUS_META = computed<Record<ExecutionInstance['status'], { label: string
 const steps = computed(() => props.instance.steps)
 const total = computed(() => steps.value.length)
 
+// A failed run is no longer executing: a step left mid-flight (state still `working`,
+// its container caught mid cold-boot) must stop looking live — no spinner, no pulse,
+// no "spinning up container" phase.
+const runFailed = computed(() => props.instance.status === 'failed')
+
 // A shared 1s tick drives every step's live elapsed clock, so a step that hasn't yet
 // emitted subtask counts still shows it is progressing rather than reading as hung.
 const nowTick = useNowTick()
@@ -172,10 +177,6 @@ function stepElapsed(s: PipelineStep): string | null {
 // human can see at a glance whether the fixer ran or was skipped.
 const companionByStep = computed(() => steps.value.map((s) => gateCompanionFor(s, runFailed.value)))
 
-// A failed run is no longer executing: a step left mid-flight (state still `working`,
-// its container caught mid cold-boot) must stop looking live — no spinner, no pulse,
-// no "spinning up container" phase.
-const runFailed = computed(() => props.instance.status === 'failed')
 /**
  * A reviewer gate (requirements-review / clarity-review) folding the answers or
  * re-reviewing in the durable driver: the step parks in `waiting_decision` but is actively

package/app/components/providers/ApiKeysSection.vue

@@ -33,6 +33,9 @@ const { confirmAction, toastDone } = useConfirmAction()
 /** Account-wide mode (single account scope) vs the default workspace/user toggle. */
 const isAccount = computed(() => !!props.accountId)
 
+/** Which store the form writes to: the shared workspace keys or the user's own. */
+const scope = ref<'workspace' | 'user'>('workspace')
+
 // "My keys" (user scope) are stored per-user, so they need a signed-in user. Block just
 // that scope when there's none (a deployment without sign-in); workspace/account keys are
 // unaffected. The scope toggle stays enabled so the user can switch back to a shared scope.
@@ -136,7 +139,6 @@ const PROVIDERS = computed(() =>
 )
 const ALL_PROVIDERS = computed(() => [...DIRECT_PROVIDERS.value, ...PROXY_PROVIDERS.value])
 
-const scope = ref<'workspace' | 'user'>('workspace')
 const provider = ref<ApiKeyProvider>(props.category === 'proxy' ? 'openrouter' : 'openai')
 const label = ref('')
 const key = ref('')

package/app/components/ralph/RalphLoopResultView.vue

@@ -19,9 +19,6 @@ const { t, d } = useI18n()
 // overlay behaviour.
 const { open, blockId, instanceId, stepIndex, close } = useResultView('ralph-loop')
 const block = computed(() => (blockId.value ? board.getBlock(blockId.value) : undefined))
-const headerTitle = computed(
-  () => `${meta.value.label}${block.value ? ` — ${block.value.title}` : ''}`,
-)
 const prUrl = computed(() => block.value?.pullRequest?.url ?? null)
 
 const instance = computed(() =>
@@ -33,6 +30,9 @@ const step = computed(() => {
 })
 const ralph = computed<RalphStepState | null>(() => step.value?.ralph ?? null)
 const meta = computed(() => agentKindMeta('ralph'))
+const headerTitle = computed(
+  () => `${meta.value.label}${block.value ? ` — ${block.value.title}` : ''}`,
+)
 
 // Iterations, newest-first for the timeline.
 const attempts = computed(() => [...(ralph.value?.attemptLog ?? [])].reverse())

package/app/components/visualConfirm/VisualConfirmationWindow.vue

@@ -131,6 +131,20 @@ function buildFindings(): { text: string; structured: { view?: string; note: str
   return { text: blocks.join('\n\n'), structured }
 }
 
+// Degraded-basis approval guard (no capture / a fix landed after these shots): require an
+// explicit "I reviewed this another way" acknowledgement before the one-click approve.
+const ackDegraded = ref(false)
+watch(
+  () => vc.value?.degradedReason ?? null,
+  () => {
+    ackDegraded.value = false
+  },
+)
+const needsAck = computed(() => !!vc.value?.degradedReason)
+const canApprove = computed(
+  () => awaitingHuman.value && !busy.value && (!needsAck.value || ackDegraded.value),
+)
+
 async function approve() {
   if (!blockId.value || !canApprove.value) return
   await visualConfirm.approve(blockId.value)
@@ -169,20 +183,6 @@ async function onFilePicked(e: Event) {
   uploadView.value = ''
   if (fileInput.value) fileInput.value.value = ''
 }
-
-// Degraded-basis approval guard (no capture / a fix landed after these shots): require an
-// explicit "I reviewed this another way" acknowledgement before the one-click approve.
-const ackDegraded = ref(false)
-watch(
-  () => vc.value?.degradedReason ?? null,
-  () => {
-    ackDegraded.value = false
-  },
-)
-const needsAck = computed(() => !!vc.value?.degradedReason)
-const canApprove = computed(
-  () => awaitingHuman.value && !busy.value && (!needsAck.value || ackDegraded.value),
-)
 </script>
 
 <template>

package/app/composables/useRunDeepLink.ts

@@ -82,10 +82,18 @@ export function useRunDeepLink(): void {
       if (!ready || applied) return
       applied = true
       if (link.blockId) ui.select(link.blockId)
-      // Two views are served: the observability panel and the Tester's result window (where the
-      // screenshots the report's environment-lifecycle section lists are rendered). An unknown
-      // view still lands the user on the right board and task rather than failing the navigation.
-      if (link.view === 'observability') ui.openObservability(link.runId)
+      // Three views are served: the run's outcome summary (the non-code answer to "what did this
+      // change"), the observability panel, and the Tester's result window (where the screenshots
+      // the report's environment-lifecycle section lists are rendered). An unknown view still
+      // lands the user on the right board and task rather than failing the navigation.
+      //
+      // `outcome` is passed the block as well as the run: it is the one of the three that stays
+      // readable on a task whose run the snapshot no longer carries, and a link followed weeks
+      // after the work merged is exactly that case. The engine emits no `view=outcome` link
+      // today (its report links a REVIEWER to the two run-scoped panels); this is the entry
+      // point for one, and for a URL a person shares.
+      if (link.view === 'outcome') ui.openRunOutcome(link.runId, link.blockId)
+      else if (link.view === 'observability') ui.openObservability(link.runId)
       else if (link.view === 'test-evidence') ui.openTestEvidence(link.runId)
       stop?.()
     },

package/app/modular/result-views.ts

@@ -1,6 +1,7 @@
 import type { Component } from 'vue'
 import { defineModule } from '@modular-vue/core'
 import { RESULT_VIEW_IDS, type ResultViewId } from '@cat-factory/contracts'
+import OutcomeSummaryWindow from '~/components/outcome/OutcomeSummaryWindow.vue'
 import RequirementsReviewWindow from '~/components/requirements/RequirementsReviewWindow.vue'
 import ClarityReviewWindow from '~/components/clarity/ClarityReviewWindow.vue'
 import BrainstormWindow from '~/components/brainstorm/BrainstormWindow.vue'
@@ -51,6 +52,9 @@ import type { ResultViewContribution } from './slots'
  * that could ship. Consumer namespaced ids are validated separately by `pairById`.
  */
 const BUILT_IN_RESULT_VIEWS: Record<ResultViewId, Component> = {
+  // The run's non-code outcome summary: what changed in product terms, with the captured
+  // evidence, and the diff one click away. RUN-keyed (no step), opened by `ui.openOutcome`.
+  outcome: OutcomeSummaryWindow,
   'requirements-review': RequirementsReviewWindow,
   'clarity-review': ClarityReviewWindow,
   // Shared by both brainstorm stages (requirements + architecture); the window reads the stage.

package/app/pages/index.vue

@@ -285,6 +285,27 @@ watch(
   { immediate: true },
 )
 
+// Probe the GitHub integration as soon as a board is active (re-probe per board —
+// connections are per workspace). The result drives the onboarding gate in the template
+// before the board mounts, so an unconnected user can't slip past it. `ensureProbed`
+// single-flights per board (app-startup initiative, item 12), so this and the SideBar's
+// probe collapse to one request on a cold open instead of two.
+watch(
+  () => workspace.workspaceId,
+  (id) => {
+    if (id) void github.ensureProbed()
+  },
+  { immediate: true },
+)
+
+// Hard gate: the App is enabled on the backend but this workspace has no
+// installation yet. `available === null` means the probe is still in flight.
+// Both are declared here, ahead of the tutorial offer below, because that offer reads them
+// from a watcher that runs synchronously during setup (`immediate: true`). Declared after
+// it, they'd still be in their TDZ and the first run would throw.
+const needsGitHubInstall = computed(() => github.available === true && !github.connected)
+const githubProbePending = computed(() => github.available === null)
+
 // Offer the tutorial on launch, once the board is up. Yields to every other startup
 // surface — the GitHub onboarding gate and the advisory/onboarding modals above — so a
 // first launch never stacks the tour prompt on top of a dialog that needs answering
@@ -347,24 +368,6 @@ useTutorialNudge()
 // simply has nothing to talk to, and the browser-persisted store carries on alone.
 useTutorialSync()
 
-// Probe the GitHub integration as soon as a board is active (re-probe per board —
-// connections are per workspace). The result drives the onboarding gate below
-// before the board mounts, so an unconnected user can't slip past it. `ensureProbed`
-// single-flights per board (app-startup initiative, item 12), so this and the SideBar's
-// probe collapse to one request on a cold open instead of two.
-watch(
-  () => workspace.workspaceId,
-  (id) => {
-    if (id) void github.ensureProbed()
-  },
-  { immediate: true },
-)
-
-// Hard gate: the App is enabled on the backend but this workspace has no
-// installation yet. `available === null` means the probe is still in flight.
-const needsGitHubInstall = computed(() => github.available === true && !github.connected)
-const githubProbePending = computed(() => github.available === null)
-
 // Subscribe to the backend's real-time event stream and (re)connect whenever the
 // active workspace changes. Runs advance durably server-side; progress arrives as
 // pushed events rather than by polling.

package/app/stores/execution.ts

@@ -131,6 +131,12 @@ export const useExecutionStore = defineStore('execution', () => {
     } else instances.value.push(instance)
   }
 
+  const byId = computed(() => {
+    const map = new Map<string, ExecutionInstance>()
+    for (const e of instances.value) map.set(e.id, e)
+    return map
+  })
+
   /**
    * Run an action that returns a run's authoritative sub-state and apply that state to the cached
    * run as an OPTIMISTIC ECHO — but only when the event stream has not delivered a newer revision
@@ -169,12 +175,6 @@ export const useExecutionStore = defineStore('execution', () => {
     return state
   }
 
-  const byId = computed(() => {
-    const map = new Map<string, ExecutionInstance>()
-    for (const e of instances.value) map.set(e.id, e)
-    return map
-  })
-
   function getInstance(id: string | null | undefined) {
     return id ? byId.value.get(id) : undefined
   }

package/app/stores/ui/resultViews.ts

@@ -113,6 +113,32 @@ export function createUiResultViews() {
     stepDetail.value = { instanceId, stepIndex }
   }
 
+  /**
+   * Open a task's NON-CODE OUTCOME summary — what the run changed in product terms, with the
+   * evidence behind it, and the diff one click away. BLOCK-keyed rather than run-keyed because a
+   * merged task keeps its pull request long after its run instance is gone, and that task is
+   * exactly the one somebody comes back to read. The run rides along when there is one, which is
+   * where every piece of evidence comes from; `stepIndex` stays null because the summary is
+   * composed from the WHOLE run and there is no step for it to be about.
+   */
+  function openOutcome(blockId: string, instanceId: string | null = null) {
+    resultView.value = { view: 'outcome', blockId, instanceId, stepIndex: null }
+  }
+
+  /**
+   * Open the outcome summary from a caller that knows the RUN: the `outcome` deep link.
+   *
+   * The run id is a LOOKUP here, not the key — the window is block-keyed (above) — so a link
+   * naming its block opens on it even when the store never hydrated that run, which is the
+   * normal state of following a link into a task that finished long ago. Falling back to the
+   * run's own `blockId` keeps a link that carries only `run=` working. Only a link that
+   * resolves neither is a silent no-op, matching the run-step openers.
+   */
+  function openRunOutcome(instanceId: string, blockId: string | null = null) {
+    const resolved = blockId ?? useExecutionStore().getInstance(instanceId)?.blockId ?? null
+    if (resolved) openOutcome(resolved, instanceId)
+  }
+
   function openRequirementReview(blockId: string) {
     resultView.value = { view: 'requirements-review', blockId, instanceId: null, stepIndex: null }
   }
@@ -185,6 +211,8 @@ export function createUiResultViews() {
     openForkDecision,
     openPrReview,
     openTestEvidence,
+    openOutcome,
+    openRunOutcome,
     closeResultView,
     closeRequirementReview,
     openStepDetail,

package/app/stores/ui.dispatch.spec.ts

@@ -134,4 +134,59 @@ describe('dispatchStepView routing', () => {
       expect(ui.stepDetail).toBeNull()
     })
   })
+
+  // The outcome summary is the RUN's, not a step's, and it has two entry points: the board and
+  // inspector know the block (and a merged task's run may be gone), while a deep link knows only
+  // the run id.
+  describe('openOutcome', () => {
+    it('opens block-keyed with no step, and with no run when the task has none', () => {
+      ui.openOutcome('b1')
+
+      expect(ui.resultView).toEqual({
+        view: 'outcome',
+        blockId: 'b1',
+        instanceId: null,
+        stepIndex: null,
+      })
+    })
+
+    it('carries the run when the caller knows it', () => {
+      ui.openOutcome('b1', 'e1')
+
+      expect(ui.resultView).toMatchObject({ view: 'outcome', blockId: 'b1', instanceId: 'e1' })
+    })
+
+    it('resolves the block from the run for a run-only caller (the deep link)', () => {
+      execution.hydrate([instance('e1', 'b1', [{ agentKind: 'coder' }])], 'ws1')
+
+      ui.openRunOutcome('e1')
+
+      expect(ui.resultView).toEqual({
+        view: 'outcome',
+        blockId: 'b1',
+        instanceId: 'e1',
+        stepIndex: null,
+      })
+    })
+
+    // The link the deep-link consumer passes carries BOTH ids, and the run is only a lookup:
+    // following one into a task that finished long ago is the normal case, and the snapshot
+    // that hydrates the board is not obliged to still carry that run.
+    it('opens on the block the link names even when the run was never hydrated', () => {
+      ui.openRunOutcome('missing', 'b1')
+
+      expect(ui.resultView).toEqual({
+        view: 'outcome',
+        blockId: 'b1',
+        instanceId: 'missing',
+        stepIndex: null,
+      })
+    })
+
+    it('does nothing for a run the store has not hydrated and a link with no block', () => {
+      ui.openRunOutcome('missing')
+
+      expect(ui.resultView).toBeNull()
+    })
+  })
 })