@cat-factory/app 0.296.2 → 0.296.4

package/app/components/fragments/FragmentLibraryManager.vue

@@ -6,7 +6,8 @@
 // the merged catalog (built-in ∪ account ∪ workspace) an agent is selected from per
 // run. The account scope has no resolved/merged catalog and fetches document
 // fragments through `viaWorkspaceId` (document-source credentials are per-workspace).
-import { computed, nextTick, reactive, ref, watch } from 'vue'
+import { computed, nextTick, ref, watch } from 'vue'
+import { useBusyRows } from '~/composables/useBusyRows'
 import type {
   DocumentSourceKind,
   FragmentOwnerKind,
@@ -108,17 +109,7 @@ function tabLabel(which: Tab): string {
 // Per-row / per-form in-flight tracking. The store's single `library.loading` flag
 // drove every row's button at once (UX-29) and cross-spun the add/link forms; key
 // each async action so only the control that triggered it shows a spinner.
-const busyRows = reactive(new Set<string>())
-const rowBusy = (key: string) => busyRows.has(key)
-async function withRow(key: string, fn: () => Promise<void>) {
-  if (busyRows.has(key)) return
-  busyRows.add(key)
-  try {
-    await fn()
-  } finally {
-    busyRows.delete(key)
-  }
-}
+const { rowBusy, withRow } = useBusyRows()
 const creating = ref(false)
 const linkingDoc = ref(false)
 const linkingSource = ref(false)

package/app/components/layout/AccountAuditLog.logic.ts

@@ -47,7 +47,7 @@ export type Translate = (key: string, params?: Record<string, string>) => string
  * Derived from the contract rather than re-listed, so an action whose fields change cannot leave
  * this behind: the `Record` it reads is exhaustive over the same picklist `ACTION_KEYS` is.
  */
-export function detailParams(
+function detailParams(
   action: AuditAction,
   details: AuditEventWire['details'],
   none: string,
@@ -61,7 +61,7 @@ export function detailParams(
 }
 
 /** Who the action was performed ON: the resolved name, else the raw id. */
-export function targetLabel(event: AuditEventWire): string {
+function targetLabel(event: AuditEventWire): string {
   return event.targetName ?? event.targetId
 }
 

package/app/components/panels/ResultWindowShell.logic.spec.ts

@@ -1,11 +1,7 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { describe, expect, it } from 'vitest'
-import {
-  PROSE_MEASURE_CLASS,
-  RESULT_WINDOW_WIDTH_CLASS,
-  type ResultWindowWidth,
-} from './ResultWindowShell.logic'
+import { PROSE_MEASURE_CLASS, type ResultWindowWidth } from './ResultWindowShell.logic'
 
 // The width decision is a per-window LAYOUT judgement that lives on each window's
 // `<ResultWindowShell width="…">`, which means nothing in the type system can ask a window author
@@ -165,22 +161,11 @@ describe('result-window width buckets', () => {
   })
 })
 
-describe('RESULT_WINDOW_WIDTH_CLASS', () => {
-  it('caps every bucket at its own name and leaves `full` uncapped', () => {
-    expect(RESULT_WINDOW_WIDTH_CLASS).toEqual({
-      '3xl': 'max-w-3xl',
-      '4xl': 'max-w-4xl',
-      '5xl': 'max-w-5xl',
-      // Not a bigger number: the panel's `w-full` spans the backdrop and the variant's gutter
-      // (`m-4` / `p-4`) is the only inset. A cap here would reintroduce the indefensible number
-      // `full` exists to avoid.
-      full: 'max-w-none',
-    })
-  })
-
-  it('shares one measure with the step reader', () => {
-    // `AgentStepDetail` reads prose at `mx-auto max-w-3xl`; the windows must not hold a second
-    // opinion about how wide prose should be.
-    expect(PROSE_MEASURE_CLASS).toBe('max-w-3xl')
+describe('PROSE_MEASURE_CLASS', () => {
+  it('is the measure the step reader already uses', () => {
+    // `AgentStepDetail` reads prose at its own measure; the windows must not hold a second
+    // opinion about how wide prose should be, so the constant is checked against that source.
+    const stepReader = readFileSync(resolve(componentsDir, 'panels/AgentStepDetail.vue'), 'utf8')
+    expect(stepReader).toContain(PROSE_MEASURE_CLASS)
   })
 })

package/app/components/panels/StepToolServers.logic.ts

@@ -81,7 +81,7 @@ export const KNOWN_REASONS = toolServerUnavailableReasonSchema.options
  * it were a translation key, taking the retired-member path away from exactly the case it exists
  * for. Narrowing at the boundary keeps the exhaustive `Record` compile-time guard intact.
  */
-export function isKnownReason(reason: string): reason is ToolServerUnavailableReason {
+function isKnownReason(reason: string): reason is ToolServerUnavailableReason {
   return (KNOWN_REASONS as readonly string[]).includes(reason)
 }
 
@@ -205,7 +205,7 @@ export const KNOWN_OBSERVED_STATUSES = toolServerObservedStatusSchema.options
  * A predicate rather than a truthiness check on the lookup, for the reason {@link isKnownReason}
  * gives: an `Object.prototype` member name reads back as a truthy non-key.
  */
-export function isKnownObservedStatus(status: string): status is ToolServerObservedStatus {
+function isKnownObservedStatus(status: string): status is ToolServerObservedStatus {
   return (KNOWN_OBSERVED_STATUSES as readonly string[]).includes(status)
 }
 

package/app/components/settings/ConsensusGroupsSection.vue

@@ -12,6 +12,7 @@
 import { computed, ref } from 'vue'
 import type { ConsensusGroup, ConsensusStrategy } from '~/types/consensus'
 import { isSelectable } from '~/stores/models'
+import { uid } from '~/utils/catalog'
 
 const { t } = useI18n()
 const groups = useConsensusGroupsStore()
@@ -52,10 +53,6 @@ interface EditorState {
 const editor = ref<EditorState | null>(null)
 const busy = ref(false)
 
-function uid(prefix: string) {
-  return `${prefix}_${Math.random().toString(36).slice(2, 9)}`
-}
-
 /** A fresh group starts as a gated two-model panel — the shape the feature is for. */
 function startCreate() {
   editor.value = {

package/app/components/settings/MergeRolePolicyEditor.logic.spec.ts

@@ -34,7 +34,6 @@ describe('narrowingOptionsFor', () => {
 describe('INHERIT_RULE', () => {
   it('is a non-empty value the select can carry as an item', () => {
     expect(INHERIT_RULE).not.toBe('')
-    expect(INHERIT_RULE.length).toBeGreaterThan(0)
   })
 
   // It is also not one of the rules, or clearing a row would be indistinguishable from setting it.

package/app/components/skills/SkillLibraryManager.vue

@@ -5,7 +5,8 @@
 // synced skill catalog a pipeline `skill` step picks from. Mirrors the fragment library's
 // repo-sources UI; when the GitHub App is connected the user searches a repo + browses to the
 // skills directory, otherwise the manual owner/name/dir fields are the fallback.
-import { computed, reactive, ref, watch } from 'vue'
+import { computed, ref, watch } from 'vue'
+import { useBusyRows } from '~/composables/useBusyRows'
 import type { GitHubAvailableRepo } from '~/types/domain'
 import { useSkillLibrary } from '~/stores/skillLibrary'
 import { SKILL_GROUP_LABEL_KEYS } from '~/utils/skills'
@@ -36,17 +37,7 @@ watch(
 const githubReady = computed(() => github.available === true && github.connected)
 
 // Per-row in-flight tracking so only the control that triggered an action spins.
-const busyRows = reactive(new Set<string>())
-const rowBusy = (key: string) => busyRows.has(key)
-async function withRow(key: string, fn: () => Promise<void>) {
-  if (busyRows.has(key)) return
-  busyRows.add(key)
-  try {
-    await fn()
-  } finally {
-    busyRows.delete(key)
-  }
-}
+const { rowBusy, withRow } = useBusyRows()
 
 // ---- link a repo source ----------------------------------------------------
 const sourceRepoId = ref<number | undefined>(undefined)

package/app/components/tutorial/TutorialOverlay.logic.ts

@@ -82,7 +82,7 @@ export function focusLeftCard(card: Node | null, relatedTarget: EventTarget | nu
  * no selector is ever built from a string that could break one, and an id that fails simply
  * finds no anchor, which the runtime already handles as a skipped step.
  */
-export const TARGET_ID_PATTERN = /^[a-z0-9-]+$/
+const TARGET_ID_PATTERN = /^[a-z0-9-]+$/
 
 /** Is this a well-formed anchor id, i.e. safe to put in a selector? */
 export function isSafeTargetId(id: string): boolean {
@@ -129,7 +129,7 @@ export function resolveSkip(
  * step's target id, since the same id (`task-card`) is a canvas node on the board and a plain
  * list row in a panel.
  */
-export const BOARD_NODE_SELECTOR = '.vue-flow__node'
+const BOARD_NODE_SELECTOR = '.vue-flow__node'
 
 /** The part of an element the reveal path needs: ancestry, and that ancestor's node id. */
 interface RevealNode {

package/app/composables/api/client.spec.ts

@@ -27,11 +27,6 @@ describe('withoutUndefinedQueryParams', () => {
     expect(out.queryParams).toEqual({ blockId: 'blk_1', page: 0, all: false, q: '' })
   })
 
-  it('drops only the undefined keys from a mixed set', () => {
-    const out = strip({ queryParams: { window: '7d', workspaceId: undefined } })
-    expect(out.queryParams).toEqual({ window: '7d' })
-  })
-
   it('leaves other request params untouched', () => {
     const params = {
       pathPrefix: '/workspaces/ws_1',

package/app/composables/useBusyRows.ts

@@ -0,0 +1,22 @@
+import { reactive } from 'vue'
+
+/**
+ * A per-row in-flight guard for lists whose rows each carry their own action buttons: a row's
+ * action runs at most once at a time, and the button it belongs to reads `rowBusy(key)` for its
+ * spinner. Keys are caller-chosen (`sync:<id>`, `unlink:<id>`), so one row can hold several
+ * independent actions.
+ */
+export function useBusyRows() {
+  const busyRows = reactive(new Set<string>())
+  const rowBusy = (key: string) => busyRows.has(key)
+  async function withRow(key: string, fn: () => Promise<void>) {
+    if (busyRows.has(key)) return
+    busyRows.add(key)
+    try {
+      await fn()
+    } finally {
+      busyRows.delete(key)
+    }
+  }
+  return { rowBusy, withRow }
+}

package/app/composables/useFrameResize.ts

@@ -35,11 +35,6 @@ const resizingId = ref<string | null>(null)
 /** The grips in render order, so a component can `v-for` them instead of listing eight blocks. */
 export const RESIZE_EDGES = Object.keys(HANDLES) as ResizeEdge[]
 
-/** The `cursor` a given grip shows, and holds on `<body>` while its drag runs. */
-export function resizeCursor(edge: ResizeEdge): string {
-  return HANDLES[edge].cursor
-}
-
 /**
  * Pointer-driven resizing for containers (service frames and modules) by dragging any border or
  * corner, Miro-style. The drag delta is divided by the board zoom so the border tracks the

package/app/composables/useSemanticZoom.ts

@@ -1,7 +1,7 @@
 import type { LodLevel } from '~/types/domain'
 
 /** The LOD scale, shallow → deep. Index order lets callers ask "is at least". */
-export const LOD_ORDER: LodLevel[] = ['far', 'mid', 'close', 'steps', 'subtasks']
+const LOD_ORDER: LodLevel[] = ['far', 'mid', 'close', 'steps', 'subtasks']
 
 /** Map a raw zoom factor to a level-of-detail bucket. Shared by the main board
  * and the drill-down focus view so both honour the same thresholds.

package/app/modular/panels/inspector.ts

@@ -91,7 +91,7 @@ const COMPONENTS: Record<InspectorPanelId, Component> = {
 }
 
 /** The built-in `PanelEntry`s: each spec's gating/order + its wrapped component. */
-export const INSPECTOR_PANEL_ENTRIES: PanelEntry<Block>[] = INSPECTOR_PANEL_SPECS.map((spec) => ({
+const INSPECTOR_PANEL_ENTRIES: PanelEntry<Block>[] = INSPECTOR_PANEL_SPECS.map((spec) => ({
   id: spec.id,
   order: spec.order,
   when: spec.when,

package/app/modular/result-views.ts

@@ -144,9 +144,10 @@ const BUILT_IN_RESULT_VIEWS: Record<ResultViewId, Component> = {
  * The built-in windows as slot entries, derived from `RESULT_VIEW_IDS` so the slot order matches
  * the canonical id order. Exhaustiveness is guaranteed by {@link BUILT_IN_RESULT_VIEWS}'s type.
  */
-export const RESULT_VIEW_CONTRIBUTIONS: readonly ResultViewContribution[] = RESULT_VIEW_IDS.map(
-  (id) => ({ id, component: BUILT_IN_RESULT_VIEWS[id] }),
-)
+const RESULT_VIEW_CONTRIBUTIONS: readonly ResultViewContribution[] = RESULT_VIEW_IDS.map((id) => ({
+  id,
+  component: BUILT_IN_RESULT_VIEWS[id],
+}))
 
 /**
  * The first-party result-views module: contributes every built-in window to the

package/app/stores/board/mutations.ts

@@ -1,10 +1,4 @@
-import type {
-  BlockType,
-  CreateTaskType,
-  FrameRepoType,
-  TaskTypeFields,
-  Block,
-} from '~/types/domain'
+import type { CreateTaskType, FrameRepoType, TaskTypeFields, Block } from '~/types/domain'
 import { useWorkspaceStore } from '~/stores/workspace'
 import type { BoardWriteContext } from './context'
 
@@ -19,12 +13,6 @@ import type { BoardWriteContext } from './context'
 export function createBoardMutations(ctx: BoardWriteContext) {
   const { getBlock, upsert, api, present } = ctx
 
-  async function addBlock(type: BlockType, position: { x: number; y: number }): Promise<Block> {
-    const block = await api.addFrame(useWorkspaceStore().requireId(), { type, position })
-    upsert(block)
-    return block
-  }
-
   /**
    * Import an existing GitHub repo (the App is installed + it's projected) as a
    * service frame, with no bootstrap run. The backend links the repo to the new
@@ -164,7 +152,6 @@ export function createBoardMutations(ctx: BoardWriteContext) {
   }
 
   return {
-    addBlock,
     addServiceFromRepo,
     addTask,
     addModule,

package/app/stores/observability/agentContext.ts

@@ -1,6 +1,7 @@
 import { ref } from 'vue'
 import type { AgentContextSnapshot, AgentSearchQuery } from '~/types/execution'
 import { useSingleFlight } from '~/composables/useSingleFlight'
+import { withFlag } from './withFlag'
 
 /** What the two reads need from the store: the workspace binding, nothing else. */
 export interface AgentContextSinkDeps {
@@ -10,14 +11,6 @@ export interface AgentContextSinkDeps {
   fetchSearchQueries: (executionId: string) => Promise<{ searchQueries: AgentSearchQuery[] }>
 }
 
-/** Add or remove a key from a reactive `Set` ref, replacing it so the reactivity fires. */
-function withFlag(set: ReturnType<typeof ref<Set<string>>>, key: string, on: boolean) {
-  const next = new Set(set.value)
-  if (on) next.add(key)
-  else next.delete(key)
-  set.value = next
-}
-
 /**
  * The observability store's AGENT-CONTEXT and SEARCH-QUERY sinks, extracted as one cohesive pair:
  * both are per-dispatch records the drill-down panel loads on open, neither is pushed live, and

package/app/stores/observability/toolCalls.ts

@@ -1,6 +1,7 @@
 import { ref } from 'vue'
 import type { RunToolCallFailures, RunToolCallTrajectory } from '~/types/execution'
 import { useSingleFlight } from '~/composables/useSingleFlight'
+import { withFlag } from './withFlag'
 
 // The observability store's TOOL-CALL sink, extracted whole because it is one concern with two
 // reads and its own coherence rule between them.
@@ -40,14 +41,6 @@ export const EMPTY_TRAJECTORY: RunToolCallTrajectory = Object.freeze({
   truncated: false,
 })
 
-/** Add or remove a key from a reactive `Set` ref, replacing it so the reactivity fires. */
-function withFlag(set: ReturnType<typeof ref<Set<string>>>, key: string, on: boolean) {
-  const next = new Set(set.value)
-  if (on) next.add(key)
-  else next.delete(key)
-  set.value = next
-}
-
 export function createToolCallSinkState(deps: ToolCallSinkDeps) {
   /**
    * One in-flight read per (sink, run). Both loads below fire on the panel OPENING, and the panel

package/app/stores/observability/withFlag.ts

@@ -0,0 +1,9 @@
+import type { Ref } from 'vue'
+
+/** Add or remove a key from a reactive `Set` ref, replacing it so the reactivity fires. */
+export function withFlag(set: Ref<Set<string>>, key: string, on: boolean) {
+  const next = new Set(set.value)
+  if (on) next.add(key)
+  else next.delete(key)
+  set.value = next
+}

package/app/types/execution.ts

@@ -92,6 +92,10 @@ export type {
   BugFishingFindingKind,
   BugFishingConfidence,
   BugFishingSpawn,
+  BugFishingTerritory,
+  BugFishingPlan,
+  BugFishingUnfishedCell,
+  BugFishingCoverage,
   AgentEffortReport,
   FragmentAdherence,
   FragmentAdherenceItem,

package/app/utils/blockRects.ts

@@ -30,7 +30,7 @@ export type BlockMeasurements = {
   rectFor: (el: Element) => DOMRect
 }
 
-export const BLOCK_ID_ATTRIBUTE = 'data-block-id'
+const BLOCK_ID_ATTRIBUTE = 'data-block-id'
 
 export function measureBlocks(root: ParentNode = document): BlockMeasurements {
   let elements: Map<string, HTMLElement> | null = null

package/app/utils/boardWakeGate.ts

@@ -34,7 +34,7 @@ export type WakeGate = {
  * instead of every frame, while a change that really did move a card is on screen well inside
  * the window a reader would notice.
  */
-export const RENDER_WAKE_INTERVAL_MS = 250
+const RENDER_WAKE_INTERVAL_MS = 250
 
 export function createWakeGate(options: {
   /** Raise the pulse. */

package/app/utils/catalog.ts

@@ -15,7 +15,7 @@ import {
 } from '@cat-factory/contracts'
 
 /** Simple unique id helper (fine for a client-only prototype). */
-export function uid(prefix = 'id'): string {
+export function uid(prefix: string): string {
   return `${prefix}_${Math.random().toString(36).slice(2, 9)}`
 }
 
@@ -1203,16 +1203,3 @@ export const FORK_DECISION_META = {
   icon: 'i-lucide-git-fork',
   color: '#a78bfa',
 }
-
-/**
- * Whether a Coder step has the Follow-up companion enabled, given the pipeline's per-step
- * `followUps` toggle at index `i`. Enabled by default on a `coder` step (only `false`
- * disables it); ignored on other kinds.
- */
-export function followUpCompanionEnabled(
-  kind: string,
-  followUps: (boolean | null)[] | undefined,
-  i: number,
-): boolean {
-  return kind === 'coder' && followUps?.[i] !== false
-}

package/app/utils/descriptorFields.spec.ts

@@ -1,7 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import type { DescriptorField } from '~/types/domain'
 import {
-  defaultDescriptorValues,
   descriptorFormRows,
   descriptorGroupValue,
   setDescriptorCheckbox,
@@ -14,50 +13,6 @@ const field = (over: Partial<DescriptorField> & Pick<DescriptorField, 'key'>): D
   ...over,
 })
 
-describe('defaultDescriptorValues', () => {
-  it('seeds each declared default in its own contract shape', () => {
-    // The form model is the wire shape, so a default has to arrive typed: the shared validator
-    // refuses a `'3'` where a `number` field is declared, and would refuse it at create time too.
-    expect(
-      defaultDescriptorValues([
-        field({ key: 'style', type: 'select', default: 'collection' }),
-        field({ key: 'depth', type: 'number', default: '3' }),
-        field({ key: 'gate', type: 'checkbox', default: 'true' }),
-        field({ key: 'ops', type: 'checkbox-group', defaultValues: ['create', 'list'] }),
-        field({ key: 'dir', type: 'path', default: 'docs' }),
-      ]),
-    ).toEqual({
-      style: 'collection',
-      depth: 3,
-      gate: true,
-      ops: ['create', 'list'],
-      dir: 'docs',
-    })
-  })
-
-  it('leaves a field with no meaningful default ABSENT rather than blank', () => {
-    // Absent is what validation reads as unset, so seeding `''`/`[]`/`false` would both freeze an
-    // empty answer and (for a required field) look filled to nothing that checks it.
-    expect(
-      defaultDescriptorValues([
-        field({ key: 'entity', type: 'text' }),
-        field({ key: 'notes', type: 'textarea', default: '' }),
-        field({ key: 'gate', type: 'checkbox' }),
-        field({ key: 'gateOff', type: 'checkbox', default: 'false' }),
-        field({ key: 'ops', type: 'checkbox-group', defaultValues: [] }),
-        field({ key: 'depth', type: 'number', default: 'not-a-number' }),
-      ]),
-    ).toEqual({})
-  })
-
-  it('copies a multi-select default, so editing the form cannot mutate the descriptor', () => {
-    const ops = field({ key: 'ops', type: 'checkbox-group', defaultValues: ['create'] })
-    const seeded = defaultDescriptorValues([ops])
-    ;(seeded.ops as string[]).push('delete')
-    expect(ops.defaultValues).toEqual(['create'])
-  })
-})
-
 describe('setDescriptorValue', () => {
   it('drops a value the shared rules read as unset rather than freezing it', () => {
     // Absent is what `validateDescriptorFields` treats as unfilled and what

package/app/utils/descriptorFields.ts

@@ -1,4 +1,4 @@
-import { descriptorFieldDefaults, descriptorFieldSections } from '@cat-factory/contracts'
+import { descriptorFieldSections } from '@cat-factory/contracts'
 import type { DescriptorField, DescriptorFieldValue, DescriptorFieldValues } from '~/types/domain'
 
 // Form-side helpers over the shared descriptor-field vocabulary (`contracts/src/form-fields.ts`),
@@ -11,18 +11,6 @@ import type { DescriptorField, DescriptorFieldValue, DescriptorFieldValues } fro
 // inside the SFC, so the mutation rules a wrong answer would freeze on an entity are unit-testable
 // without mounting a component.
 
-/**
- * The initial values a field list implies, for seeding a freshly opened form. A repo-detection
- * probe's prefill and the user's own edits layer on top.
- *
- * The SHARED helper, not a form-side copy: the server folds the same defaults in at the creation
- * door (`withDescriptorFieldDefaults`), so a duplicate here would be the drift that made a headless
- * caller and this form disagree about what a descriptor's default means.
- */
-export function defaultDescriptorValues(fields: readonly DescriptorField[]): DescriptorFieldValues {
-  return descriptorFieldDefaults(fields)
-}
-
 /**
  * A value that must stay ABSENT from the bag rather than freeze on the entity: an unchecked
  * (`false`) checkbox, a blank string, an empty multi-select, or a number that is not one (a

package/app/utils/dnd.ts

@@ -1,29 +1,5 @@
-import type { BlockType } from '~/types/domain'
-
-/** MIME-ish key used to carry palette payloads across the HTML5 DnD boundary. */
-export const DND_MIME = 'application/agent-board'
-
-export type DndPayload =
-  | { kind: 'block'; blockType: BlockType }
-  | { kind: 'pipeline'; pipelineId: string }
-
-export function setDndPayload(event: DragEvent, payload: DndPayload) {
-  event.dataTransfer?.setData(DND_MIME, JSON.stringify(payload))
-  if (event.dataTransfer) event.dataTransfer.effectAllowed = 'copy'
-}
-
-export function readDndPayload(event: DragEvent): DndPayload | null {
-  const raw = event.dataTransfer?.getData(DND_MIME)
-  if (!raw) return null
-  try {
-    return JSON.parse(raw) as DndPayload
-  } catch {
-    return null
-  }
-}
-
 /** Walk up from an event's target to find the block it landed on, if any. Works for any
- * DOM event (drop, double-click, …) — only `event.target` is read. */
+ * DOM event (double-click, context menu, …): only `event.target` is read. */
 export function blockIdFromEvent(event: Event): string | null {
   const el = (event.target as HTMLElement | null)?.closest('[data-block-id]')
   return el?.getAttribute('data-block-id') ?? null

package/app/utils/initiative.ts

@@ -79,7 +79,7 @@ export const INITIATIVE_ATTENTION_ICONS: Record<InitiativeAttentionKind, string>
  * interview park is already owned by the planning window, behind the differently-worded "Answer
  * planning questions".
  */
-export const INTERVIEW_GATE_RESULT_VIEW = 'initiative-planning'
+const INTERVIEW_GATE_RESULT_VIEW = 'initiative-planning'
 
 /**
  * The block's parked approval that is a PLAN REVIEW — the planner's human gate (`pl_initiative`

package/app/utils/settlingLoop.ts

@@ -41,7 +41,7 @@ export type SettlingLoop = {
  * unchanged frame would miss every animation. Four frames (~66ms at 60Hz) clears that gap
  * while keeping a false wake-up cheap.
  */
-export const DEFAULT_SETTLE_FRAMES = 4
+const DEFAULT_SETTLE_FRAMES = 4
 
 export function createSettlingLoop(options: {
   /** Runs one frame; returns whether it changed anything the user can see. */

package/app/utils/taskExpansionRanking.spec.ts

@@ -1,14 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import { headerDistanceSq, type Rect } from './taskExpansionRanking'
 
-/** Rank a set of cards against a screen centre, best (would-expand) first. */
-function rank(cards: Record<string, Rect>, cx: number, cy: number): string[] {
-  return Object.entries(cards)
-    .map(([id, rect]) => ({ id, dist: headerDistanceSq(rect, cx, cy) }))
-    .sort((a, b) => a.dist - b.dist)
-    .map((c) => c.id)
-}
-
 describe('headerDistanceSq', () => {
   it('measures from the centre of the card top edge', () => {
     const r: Rect = { left: 0, right: 100, top: 200, bottom: 600 }
@@ -25,27 +17,26 @@ describe('headerDistanceSq', () => {
   })
 })
 
-describe('ranking', () => {
-  // The regression from the screenshot: a tall card parked at the top of the screen
-  // expands its pipeline down past the centre, so its body covers the centre. A compact
-  // card whose header sits right at the centre must still win — the one you're looking at.
+describe('ordering by header distance', () => {
+  // `useTaskExpansion` sorts candidates by this measure, so the card with the smaller value is
+  // the one that expands. The regression from the screenshot: a tall card parked at the top of
+  // the screen expands its pipeline down past the centre, so its body covers the centre. A
+  // compact card whose header sits right at the centre must still win.
   it('prefers the card whose header is at the centre over a tall card bleeding down from the top', () => {
     const top: Rect = { left: 0, right: 200, top: 30, bottom: 700 } // header far up, body covers centre
     const here: Rect = { left: 0, right: 200, top: 320, bottom: 520 } // header at the centre
-    expect(rank({ top, here }, 100, 340)).toEqual(['here', 'top'])
-    // document order can't flip the winner
-    expect(rank({ here, top }, 100, 340)).toEqual(['here', 'top'])
+    expect(headerDistanceSq(here, 100, 340)).toBeLessThan(headerDistanceSq(top, 100, 340))
   })
 
   it('ranks by the header nearest the centre regardless of expansion state', () => {
     const above: Rect = { left: 0, right: 200, top: 100, bottom: 800 }
     const below: Rect = { left: 0, right: 200, top: 360, bottom: 420 }
-    expect(rank({ above, below }, 100, 320)).toEqual(['below', 'above'])
+    expect(headerDistanceSq(below, 100, 320)).toBeLessThan(headerDistanceSq(above, 100, 320))
   })
 
   it('uses horizontal offset to break a vertical tie', () => {
     const near: Rect = { left: 0, right: 100, top: 100, bottom: 200 }
     const far: Rect = { left: 400, right: 500, top: 100, bottom: 200 }
-    expect(rank({ far, near }, 80, 100)).toEqual(['near', 'far'])
+    expect(headerDistanceSq(near, 80, 100)).toBeLessThan(headerDistanceSq(far, 80, 100))
   })
 })

package/app/utils/tutorial.ts

@@ -188,7 +188,7 @@ export const TARGET_IDLE_INTERVAL_MS = 400
  * two means "mostly visible" for a small control and "filling a good part of the screen" for a
  * large one, which is the same judgement in both cases.
  */
-export const MIN_VISIBLE_RATIO = 0.5
+const MIN_VISIBLE_RATIO = 0.5
 
 /** Deterministic tour-list order: `order`, then `id`. */
 export function sortTours(tours: readonly TutorialTour[]): TutorialTour[] {

package/app/utils/uiMode.spec.ts

@@ -27,7 +27,6 @@ describe('resolveUiMode', () => {
   it('falls back to the stored choice, then to the default', () => {
     expect(resolveUiMode(null, 'advanced')).toBe('advanced')
     expect(resolveUiMode(null, null)).toBe(DEFAULT_UI_MODE)
-    expect(DEFAULT_UI_MODE).toBe('basic')
   })
 
   it('caps an intake role at basic, above BOTH the env pin and the stored choice', () => {

package/app/utils/uiRole.ts

@@ -28,7 +28,7 @@ export type UiRole = (typeof UI_ROLES)[number]
  * The first-run prompt is offered once per session until it is answered (see `stores/uiRole.ts`),
  * and closing it leaves the whole product in place rather than guessing a narrower persona.
  */
-export const DEFAULT_UI_ROLE: UiRole = 'engineer'
+const DEFAULT_UI_ROLE: UiRole = 'engineer'
 
 /**
  * How much of the SPA a role is offered.