@cat-factory/app 0.33.0 → 0.35.0

package/app/components/settings/LocalModeSettingsPanel.vue

@@ -0,0 +1,159 @@
+<script setup lang="ts">
+// Local-mode-only settings: the warm-container pool + per-repo checkout reuse. These are
+// a per-DEPLOYMENT singleton stored in the DB (they replaced the LOCAL_POOL_* / HARNESS_*
+// env vars), so a developer tunes them here instead of editing .env. The warm pool keeps
+// idle harness containers ready and re-leases one (preferring repo affinity) to each run —
+// far faster startup than a cold container per run. Saving applies the new sizing to the
+// running service immediately (the pool is resized live — no restart needed); in-flight
+// runs keep the container they already hold, and the checkout config applies to containers
+// started after the save.
+import { reactive, ref, watch } from 'vue'
+
+const ui = useUiStore()
+const store = useLocalSettingsStore()
+const toast = useToast()
+
+const open = computed({
+  get: () => ui.localModeSettingsOpen,
+  set: (v: boolean) => (v ? ui.openLocalModeSettings() : ui.closeLocalModeSettings()),
+})
+
+const saving = ref(false)
+
+// Editable draft. `idleMinutes` and `cleanKeep` are friendlier renderings of the stored
+// `pool.idleTtlMs` (ms) and `checkout.cleanKeep` (string[]).
+const draft = reactive({
+  size: 0,
+  minWarm: 0,
+  max: null as number | null,
+  idleMinutes: 10,
+  workspaceRoot: '/workspace',
+  cleanKeep: 'node_modules,.venv,target,.gradle,.pnpm-store',
+})
+
+function syncDraft() {
+  const s = store.settings
+  if (!s) return
+  draft.size = s.pool.size
+  draft.minWarm = s.pool.minWarm
+  draft.max = s.pool.max
+  draft.idleMinutes = Math.round(s.pool.idleTtlMs / 60_000)
+  draft.workspaceRoot = s.checkout.workspaceRoot
+  draft.cleanKeep = s.checkout.cleanKeep.join(',')
+}
+
+// Load + hydrate the draft whenever the panel opens.
+watch(open, (isOpen) => {
+  if (isOpen) void store.load().then(syncDraft)
+})
+watch(() => store.settings, syncDraft)
+
+async function save() {
+  const cleanKeep = draft.cleanKeep
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+  saving.value = true
+  try {
+    await store.save({
+      pool: {
+        size: Math.max(0, Math.floor(draft.size)),
+        minWarm: Math.max(0, Math.floor(draft.minWarm)),
+        max: draft.max == null ? null : Math.max(0, Math.floor(draft.max)),
+        idleTtlMs: Math.max(0, Math.floor(draft.idleMinutes * 60_000)),
+      },
+      checkout: { workspaceRoot: draft.workspaceRoot.trim() || '/workspace', cleanKeep },
+    })
+    toast.add({ title: 'Local settings saved', icon: 'i-lucide-check', color: 'success' })
+  } catch (e) {
+    toast.add({
+      title: 'Could not save local settings',
+      description: e instanceof Error ? e.message : String(e),
+      icon: 'i-lucide-triangle-alert',
+      color: 'error',
+    })
+  } finally {
+    saving.value = false
+  }
+}
+</script>
+
+<template>
+  <UModal v-model:open="open" title="Local mode" :ui="{ content: 'max-w-2xl' }">
+    <template #body>
+      <div class="space-y-6">
+        <p class="text-xs text-slate-400">
+          Tuning for the local container runner — stored on this machine's deployment (it replaced
+          the <code>LOCAL_POOL_*</code> / <code>HARNESS_*</code> env vars). Saving resizes the warm
+          pool live — no restart needed; in-flight runs keep the container they already hold.
+        </p>
+
+        <!-- Warm container pool -->
+        <section class="space-y-3">
+          <div>
+            <h4 class="text-sm font-semibold text-slate-200">Warm container pool</h4>
+            <p class="text-[11px] text-slate-400">
+              Keep idle harness containers ready and re-lease one (preferring a container that
+              already holds the run's repo) instead of cold-starting per run. Pool size 0 disables
+              it. Requires a Docker-family runtime (Docker/Podman/OrbStack/Colima); ignored on Apple
+              <code>container</code>.
+            </p>
+          </div>
+          <div class="grid grid-cols-1 gap-3 sm:grid-cols-2">
+            <UFormField label="Pool size" help="Max idle warm containers. 0 = pooling off.">
+              <UInput v-model.number="draft.size" type="number" :min="0" size="sm" />
+            </UFormField>
+            <UFormField label="Pre-warm at boot" help="Containers started when the service boots.">
+              <UInput v-model.number="draft.minWarm" type="number" :min="0" size="sm" />
+            </UFormField>
+            <UFormField label="Max containers" help="Hard cap (leased + idle). Blank = pool size.">
+              <UInput
+                v-model.number="draft.max"
+                type="number"
+                :min="0"
+                size="sm"
+                placeholder="(pool size)"
+              />
+            </UFormField>
+            <UFormField label="Idle timeout (minutes)" help="Evict an idle pooled container after.">
+              <UInput v-model.number="draft.idleMinutes" type="number" :min="0" size="sm" />
+            </UFormField>
+          </div>
+        </section>
+
+        <!-- Checkout reuse -->
+        <section class="space-y-3 border-t border-slate-800 pt-6">
+          <div>
+            <h4 class="text-sm font-semibold text-slate-200">Checkout reuse</h4>
+            <p class="text-[11px] text-slate-400">
+              When a warm container already holds the run's repo, the harness reuses its per-repo
+              checkout (clean sweep + fetch + switch branch) instead of cloning fresh.
+            </p>
+          </div>
+          <UFormField
+            label="Workspace root"
+            help="Absolute in-container directory the reused checkout lives under."
+          >
+            <UInput v-model="draft.workspaceRoot" size="sm" placeholder="/workspace" />
+          </UFormField>
+          <UFormField
+            label="Keep on clean (comma-separated)"
+            help="Dependency-cache directories the per-run clean sweep preserves."
+          >
+            <UInput
+              v-model="draft.cleanKeep"
+              size="sm"
+              placeholder="node_modules,.venv,target,.gradle,.pnpm-store"
+            />
+          </UFormField>
+        </section>
+
+        <div class="flex justify-end">
+          <UButton color="primary" icon="i-lucide-save" :loading="saving" @click="save">
+            Save
+          </UButton>
+        </div>
+      </div>
+    </template>
+  </UModal>
+</template>

package/app/components/settings/ServiceFragmentDefaultsPanel.vue

@@ -8,6 +8,7 @@ import { onMounted, ref } from 'vue'
 
 const fragments = useFragmentsStore()
 const defaults = useServiceFragmentDefaultsStore()
+const ui = useUiStore()
 const toast = useToast()
 
 const busy = ref(false)
@@ -105,5 +106,25 @@ function remove(id: string) {
     <p v-else class="text-[11px] text-slate-500">
       None — new services start with no service-level fragments.
     </p>
+
+    <div class="flex flex-wrap gap-x-4 gap-y-1 border-t border-slate-800 pt-3 text-[11px]">
+      <span class="text-slate-500">
+        Need to add or edit the fragments themselves (hand-authored, linked docs, repos)?
+      </span>
+      <button
+        type="button"
+        class="font-medium text-primary-400 hover:underline"
+        @click="ui.openFragmentLibrary()"
+      >
+        Manage this board's fragment library →
+      </button>
+      <button
+        type="button"
+        class="font-medium text-primary-400 hover:underline"
+        @click="ui.openAccountSettings('fragments')"
+      >
+        Manage account fragments →
+      </button>
+    </div>
   </div>
 </template>

package/app/composables/api/fragments.ts

@@ -53,10 +53,19 @@ export function fragmentsApi({ http, ws, scope }: ApiContext) {
       body: CreateDocumentFragmentInput,
     ) => http<PromptFragment>(`${scope(kind, id)}/document-fragments`, { method: 'POST', body }),
 
-    // Force an immediate live re-resolve of a document-backed fragment.
-    refreshFragment: (kind: FragmentOwnerKind, id: string, fragmentId: string) =>
+    // Force an immediate live re-resolve of a document-backed fragment. At the
+    // account scope the backend needs a `viaWorkspaceId` (the workspace whose
+    // document-source connection to fetch through); it is ignored at workspace scope.
+    refreshFragment: (
+      kind: FragmentOwnerKind,
+      id: string,
+      fragmentId: string,
+      viaWorkspaceId?: string,
+    ) =>
       http<PromptFragment>(
-        `${scope(kind, id)}/prompt-fragments/${encodeURIComponent(fragmentId)}/refresh`,
+        `${scope(kind, id)}/prompt-fragments/${encodeURIComponent(fragmentId)}/refresh${
+          viaWorkspaceId ? `?viaWorkspaceId=${encodeURIComponent(viaWorkspaceId)}` : ''
+        }`,
         { method: 'POST' },
       ),
 

package/app/composables/api/localSettings.ts

@@ -0,0 +1,17 @@
+import type { LocalSettings, UpdateLocalSettingsInput } from '~/types/localSettings'
+import type { ApiContext } from './context'
+
+/**
+ * Local-mode operational settings (warm-container-pool sizing + per-repo checkout reuse) —
+ * a per-deployment singleton. Wired only on the local-mode service; both calls 503 on the
+ * Worker / stock Node facades (the store hides the panel then). No secrets, so the read view
+ * is the plain config and the write replaces it wholesale.
+ */
+export function localSettingsApi({ http }: ApiContext) {
+  return {
+    getLocalSettings: () => http<LocalSettings>('/local-settings'),
+
+    updateLocalSettings: (body: UpdateLocalSettingsInput) =>
+      http<LocalSettings>('/local-settings', { method: 'PUT', body }),
+  }
+}

package/app/composables/useApi.ts

@@ -11,6 +11,7 @@ import { fragmentsApi } from './api/fragments'
 import { githubApi } from './api/github'
 import { humanTestApi } from './api/humanTest'
 import { kaizenApi } from './api/kaizen'
+import { localSettingsApi } from './api/localSettings'
 import { modelsApi } from './api/models'
 import { notificationsApi } from './api/notifications'
 import { presetsApi } from './api/presets'
@@ -89,6 +90,7 @@ export function useApi() {
     ...followUpsApi(ctx),
     ...humanTestApi(ctx),
     ...kaizenApi(ctx),
+    ...localSettingsApi(ctx),
     ...specApi(ctx),
     ...notificationsApi(ctx),
     ...presetsApi(ctx),

package/app/pages/index.vue

@@ -35,6 +35,7 @@ import ProviderConnectionPanel from '~/components/settings/ProviderConnectionPan
 import ProviderConfigBanner from '~/components/layout/ProviderConfigBanner.vue'
 import ModelConfigurationPanel from '~/components/settings/ModelConfigurationPanel.vue'
 import LocalModelEndpointsPanel from '~/components/settings/LocalModelEndpointsPanel.vue'
+import LocalModeSettingsPanel from '~/components/settings/LocalModeSettingsPanel.vue'
 import SandboxPanel from '~/components/sandbox/SandboxPanel.vue'
 import UserSecretsSection from '~/components/settings/UserSecretsSection.vue'
 import OpenRouterCatalogPanel from '~/components/settings/OpenRouterCatalogPanel.vue'
@@ -194,6 +195,7 @@ watch(
       <ProviderConnectionPanel />
       <ModelConfigurationPanel />
       <LocalModelEndpointsPanel />
+      <LocalModeSettingsPanel />
       <SandboxPanel />
       <UserSecretsSection />
       <OpenRouterCatalogPanel />

package/app/stores/fragmentLibrary.ts

@@ -3,6 +3,7 @@ import { computed, ref } from 'vue'
 import type {
   CreateDocumentFragmentInput,
   CreatePromptFragmentInput,
+  FragmentOwnerKind,
   FragmentSource,
   LinkFragmentSourceInput,
   PromptFragment,
@@ -12,40 +13,62 @@ import type {
 import { useWorkspaceStore } from '~/stores/workspace'
 
 /**
- * Prompt-fragment library state (ADR 0006), scoped to the active board. Holds the
- * board's own (workspace-tier) fragments, its linked guideline repos, and the
- * merged catalog an agent actually sees (built-in ∪ account ∪ workspace). The
- * management surface targets the workspace tier; the resolved read is what every
- * agent run is selected from. `available` mirrors the backend's opt-in gate: a
- * 503 from the resolve probe means the feature is off and the UI hides its entry.
+ * Prompt-fragment library state (ADR 0006), scoped to a single owner — a board
+ * (`workspace`) or an account. Holds that owner's own (raw) tier fragments, its
+ * linked guideline repos, and — for the **workspace** tier only — the merged
+ * catalog an agent actually sees (built-in ∪ account ∪ workspace). `available`
+ * mirrors the backend's opt-in gate: a 503 from the probe means the feature is off
+ * and the UI hides its entry.
+ *
+ * Two entry points share this setup: `useFragmentLibraryStore` (the workspace
+ * singleton that follows the active board, used by the navbar + the board modal)
+ * and `useFragmentLibrary(kind, ownerId)` (an owner-keyed store, used for the
+ * account tier). The account tier has no resolved/merged catalog and, for
+ * document-backed fragments, needs a `viaWorkspaceId` (document-source credentials
+ * are per-workspace).
  */
-export const useFragmentLibraryStore = defineStore('fragmentLibrary', () => {
+function fragmentLibrarySetup(kind: FragmentOwnerKind, resolveOwnerId: () => string | null) {
   const api = useApi()
-  const workspace = useWorkspaceStore()
+
+  /** The merged/resolved catalog only exists at the workspace tier. */
+  const hasResolved = kind === 'workspace'
 
   /** null = not probed yet; true/false = library on/off. */
   const available = ref<boolean | null>(null)
-  /** This board's hand-authored + sourced fragments (workspace tier, raw). */
+  /** This owner's hand-authored + sourced fragments (its own tier, raw). */
   const fragments = ref<PromptFragment[]>([])
-  /** The merged catalog an agent sees (with each entry's winning tier). */
+  /** The merged catalog an agent sees (workspace tier only; empty otherwise). */
   const resolved = ref<ResolvedFragment[]>([])
-  /** Linked guideline repos for this board. */
+  /** Linked guideline repos for this owner. */
   const sources = ref<FragmentSource[]>([])
   /** Per-source "changes available" counts from the last status check. */
   const sourceChanges = ref<Record<string, number>>({})
   const loading = ref(false)
+  /**
+   * Account-tier document fragments only: the workspace whose stored
+   * document-source connection is used to fetch/refresh the page (credentials are
+   * per-workspace). Set by the caller; ignored at the workspace scope (the owner
+   * board is used directly).
+   */
+  const viaWorkspaceId = ref<string | undefined>(undefined)
 
   const builtinCount = computed(() => resolved.value.filter((f) => f.tier === 'builtin').length)
 
-  /** Probe the feature + load this board's tier, sources and resolved catalog. */
+  function requireOwnerId(): string {
+    const id = resolveOwnerId()
+    if (!id) throw new Error('No fragment-library owner')
+    return id
+  }
+
+  /** Probe the feature + load this owner's tier, sources and (ws) resolved catalog. */
   async function probe() {
-    if (!workspace.workspaceId) return
-    const id = workspace.requireId()
+    const id = resolveOwnerId()
+    if (!id) return
     try {
       const [tier, srcs, merged] = await Promise.all([
-        api.listFragments('workspace', id),
-        api.listFragmentSources('workspace', id).catch(() => [] as FragmentSource[]),
-        api.getResolvedFragments(id),
+        api.listFragments(kind, id),
+        api.listFragmentSources(kind, id).catch(() => [] as FragmentSource[]),
+        hasResolved ? api.getResolvedFragments(id) : Promise.resolve([] as ResolvedFragment[]),
       ])
       fragments.value = tier
       sources.value = srcs
@@ -60,13 +83,14 @@ export const useFragmentLibraryStore = defineStore('fragmentLibrary', () => {
   }
 
   async function refreshResolved() {
-    resolved.value = await api.getResolvedFragments(workspace.requireId())
+    if (!hasResolved) return
+    resolved.value = await api.getResolvedFragments(requireOwnerId())
   }
 
   async function create(input: CreatePromptFragmentInput) {
     loading.value = true
     try {
-      await api.createFragment('workspace', workspace.requireId(), input)
+      await api.createFragment(kind, requireOwnerId(), input)
       await Promise.all([reloadTier(), refreshResolved()])
     } finally {
       loading.value = false
@@ -74,7 +98,7 @@ export const useFragmentLibraryStore = defineStore('fragmentLibrary', () => {
   }
 
   async function update(fragmentId: string, patch: UpdatePromptFragmentInput) {
-    await api.updateFragment('workspace', workspace.requireId(), fragmentId, patch)
+    await api.updateFragment(kind, requireOwnerId(), fragmentId, patch)
     await Promise.all([reloadTier(), refreshResolved()])
   }
 
@@ -82,7 +106,10 @@ export const useFragmentLibraryStore = defineStore('fragmentLibrary', () => {
   async function createDocumentFragment(input: CreateDocumentFragmentInput) {
     loading.value = true
     try {
-      await api.createDocumentFragment('workspace', workspace.requireId(), input)
+      await api.createDocumentFragment(kind, requireOwnerId(), {
+        ...input,
+        ...(viaWorkspaceId.value ? { viaWorkspaceId: viaWorkspaceId.value } : {}),
+      })
       await Promise.all([reloadTier(), refreshResolved()])
     } finally {
       loading.value = false
@@ -93,31 +120,31 @@ export const useFragmentLibraryStore = defineStore('fragmentLibrary', () => {
   async function refreshDocumentFragment(fragmentId: string) {
     loading.value = true
     try {
-      await api.refreshFragment('workspace', workspace.requireId(), fragmentId)
+      await api.refreshFragment(kind, requireOwnerId(), fragmentId, viaWorkspaceId.value)
       await Promise.all([reloadTier(), refreshResolved()])
     } finally {
       loading.value = false
     }
   }
 
-  /** Tombstone a fragment at the workspace tier (suppresses an inherited one). */
+  /** Tombstone a fragment at this tier (suppresses an inherited one). */
   async function remove(fragmentId: string) {
-    await api.deleteFragment('workspace', workspace.requireId(), fragmentId)
+    await api.deleteFragment(kind, requireOwnerId(), fragmentId)
     await Promise.all([reloadTier(), refreshResolved()])
   }
 
   async function reloadTier() {
-    fragments.value = await api.listFragments('workspace', workspace.requireId())
+    fragments.value = await api.listFragments(kind, requireOwnerId())
   }
 
   async function linkSource(input: LinkFragmentSourceInput) {
-    const source = await api.linkFragmentSource('workspace', workspace.requireId(), input)
+    const source = await api.linkFragmentSource(kind, requireOwnerId(), input)
     sources.value = [source, ...sources.value]
     return source
   }
 
   async function unlinkSource(sourceId: string) {
-    await api.unlinkFragmentSource('workspace', workspace.requireId(), sourceId)
+    await api.unlinkFragmentSource(kind, requireOwnerId(), sourceId)
     sources.value = sources.value.filter((s) => s.id !== sourceId)
     await refreshResolved()
   }
@@ -126,7 +153,7 @@ export const useFragmentLibraryStore = defineStore('fragmentLibrary', () => {
   async function syncSource(sourceId: string) {
     loading.value = true
     try {
-      const result = await api.syncFragmentSource('workspace', workspace.requireId(), sourceId)
+      const result = await api.syncFragmentSource(kind, requireOwnerId(), sourceId)
       delete sourceChanges.value[sourceId]
       await Promise.all([reloadSources(), refreshResolved()])
       return result
@@ -137,7 +164,7 @@ export const useFragmentLibraryStore = defineStore('fragmentLibrary', () => {
 
   /** Cheap "check for changes" for a source; caches the changed count. */
   async function checkSource(sourceId: string) {
-    const status = await api.fragmentSourceStatus('workspace', workspace.requireId(), sourceId)
+    const status = await api.fragmentSourceStatus(kind, requireOwnerId(), sourceId)
     sourceChanges.value = {
       ...sourceChanges.value,
       [sourceId]: status.changed ? status.changedCount : 0,
@@ -146,16 +173,19 @@ export const useFragmentLibraryStore = defineStore('fragmentLibrary', () => {
   }
 
   async function reloadSources() {
-    sources.value = await api.listFragmentSources('workspace', workspace.requireId())
+    sources.value = await api.listFragmentSources(kind, requireOwnerId())
   }
 
   return {
+    kind,
+    hasResolved,
     available,
     fragments,
     resolved,
     sources,
     sourceChanges,
     loading,
+    viaWorkspaceId,
     builtinCount,
     probe,
     refreshResolved,
@@ -169,4 +199,23 @@ export const useFragmentLibraryStore = defineStore('fragmentLibrary', () => {
     syncSource,
     checkSource,
   }
-})
+}
+
+/**
+ * The workspace-tier library for the **active** board — a singleton that resolves
+ * the owner lazily, so it follows board switches and is shared by the navbar
+ * (SideBar/CommandBar probes) and the board fragment modal.
+ */
+export const useFragmentLibraryStore = defineStore('fragmentLibrary', () =>
+  fragmentLibrarySetup('workspace', () => useWorkspaceStore().workspaceId),
+)
+
+/**
+ * An owner-keyed library store, used for the **account** tier (and reusable for any
+ * explicit owner). Keyed by `(kind, ownerId)` so each account gets isolated state.
+ */
+export function useFragmentLibrary(kind: FragmentOwnerKind, ownerId: string) {
+  return defineStore(`fragmentLibrary:${kind}:${ownerId}`, () =>
+    fragmentLibrarySetup(kind, () => ownerId),
+  )()
+}

package/app/stores/localSettings.ts

@@ -0,0 +1,48 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { LocalSettings, UpdateLocalSettingsInput } from '~/types/localSettings'
+
+/**
+ * Local-mode operational settings (warm-container-pool sizing + per-repo checkout reuse) —
+ * a per-deployment singleton that replaced the old LOCAL_POOL_* / HARNESS_* env vars. No
+ * secrets, so the store holds the full config. `available` mirrors the backend opt-in: a 503
+ * (not the local-mode service) hides the panel. Loaded on demand from the settings panel.
+ */
+export const useLocalSettingsStore = defineStore('localSettings', () => {
+  const api = useApi()
+
+  const settings = ref<LocalSettings | null>(null)
+  const loading = ref(false)
+  const available = ref<boolean | null>(null)
+
+  async function load() {
+    loading.value = true
+    try {
+      settings.value = await api.getLocalSettings()
+      available.value = true
+    } catch (e) {
+      // 503 ⇒ not the local-mode service ⇒ hide the panel.
+      if (
+        e &&
+        typeof e === 'object' &&
+        'statusCode' in e &&
+        (e as { statusCode?: number }).statusCode === 503
+      ) {
+        available.value = false
+        settings.value = null
+      } else {
+        throw e
+      }
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function save(input: UpdateLocalSettingsInput) {
+    settings.value = await api.updateLocalSettings(input)
+    available.value = true
+    return settings.value
+  }
+
+  return { settings, loading, available, load, save }
+})

package/app/stores/ui.ts

@@ -96,9 +96,13 @@ export const useUiStore = defineStore('ui', () => {
   // `workspaceSettingsTab` lets other surfaces deep-link straight to a tab.
   const workspaceSettingsOpen = ref(false)
   const workspaceSettingsTab = ref('workspace')
-  // Account/team-settings modal: the per-account members + roles + invitations + email
-  // sender panel (`AccountTeamSettings`). Account-scoped (distinct from workspace settings).
+  // Account-settings modal: a single tabbed window for the per-account configuration —
+  // the team panel (members + roles + invitations + email sender + account API keys,
+  // `AccountTeamSettings`) and the account-tier prompt-fragment library. Account-scoped
+  // (distinct from workspace settings). `accountSettingsTab` lets other surfaces deep-link
+  // straight to a tab.
   const accountSettingsOpen = ref(false)
+  const accountSettingsTab = ref('team')
   // Observability integration: the post-release-health connection panel (Datadog
   // today, pluggable). NB: distinct from `observabilityInstanceId` below, which is the
   // LLM per-call observability panel.
@@ -112,6 +116,9 @@ export const useUiStore = defineStore('ui', () => {
   const vendorCredentialsOpen = ref(false)
   // Per-user settings panel: the signed-in user's own-machine local model runners.
   const localModelsOpen = ref(false)
+  // Local-mode-only settings panel: the warm-container pool sizing + per-repo checkout reuse
+  // (a per-deployment singleton that replaced the LOCAL_POOL_* / HARNESS_* env vars).
+  const localModeSettingsOpen = ref(false)
   // The Sandbox (parallel prompt/model testing) surface — an opt-in, on-demand window.
   const sandboxOpen = ref(false)
   const userSecretsOpen = ref(false)
@@ -383,13 +390,17 @@ export const useUiStore = defineStore('ui', () => {
   function setWorkspaceSettingsTab(tab: string) {
     workspaceSettingsTab.value = tab
   }
-  function openAccountSettings() {
+  function openAccountSettings(tab = 'team') {
     cameFromIntegrations.value = false
+    accountSettingsTab.value = tab
     accountSettingsOpen.value = true
   }
   function closeAccountSettings() {
     accountSettingsOpen.value = false
   }
+  function setAccountSettingsTab(tab: string) {
+    accountSettingsTab.value = tab
+  }
   function openObservabilityConnection() {
     cameFromIntegrations.value = false
     observabilityConnectionOpen.value = true
@@ -424,6 +435,13 @@ export const useUiStore = defineStore('ui', () => {
   function closeLocalModels() {
     localModelsOpen.value = false
   }
+  function openLocalModeSettings() {
+    cameFromIntegrations.value = false
+    localModeSettingsOpen.value = true
+  }
+  function closeLocalModeSettings() {
+    localModeSettingsOpen.value = false
+  }
   function openSandbox() {
     sandboxOpen.value = true
   }
@@ -566,11 +584,13 @@ export const useUiStore = defineStore('ui', () => {
     workspaceSettingsOpen,
     workspaceSettingsTab,
     accountSettingsOpen,
+    accountSettingsTab,
     observabilityConnectionOpen,
     providerConnectionKind,
     modelConfigOpen,
     vendorCredentialsOpen,
     localModelsOpen,
+    localModeSettingsOpen,
     sandboxOpen,
     userSecretsOpen,
     openRouterOpen,
@@ -630,6 +650,7 @@ export const useUiStore = defineStore('ui', () => {
     setWorkspaceSettingsTab,
     openAccountSettings,
     closeAccountSettings,
+    setAccountSettingsTab,
     openObservabilityConnection,
     closeObservabilityConnection,
     openProviderConnection,
@@ -640,6 +661,8 @@ export const useUiStore = defineStore('ui', () => {
     closeVendorCredentials,
     openLocalModels,
     closeLocalModels,
+    openLocalModeSettings,
+    closeLocalModeSettings,
     openSandbox,
     closeSandbox,
     openUserSecrets,

package/app/types/localSettings.ts

@@ -0,0 +1,31 @@
+// Local-mode operational settings (warm-container-pool sizing + per-repo checkout reuse).
+// Mirrors `@cat-factory/contracts` localSettings. A per-deployment singleton, edited in the
+// dedicated local-mode settings panel — these replaced the old LOCAL_POOL_* / HARNESS_* env
+// vars. There are no secrets, so the read view is the plain config. Local-mode-only (the
+// warm pool is the local Docker-family runner's differentiator).
+
+export interface LocalPoolSettings {
+  /** Max idle warm containers kept for re-lease. 0 disables pooling (cold-start per run). */
+  size: number
+  /** Containers pre-warmed when the service starts. */
+  minWarm: number
+  /** Hard cap on total containers (leased + idle). `null` ⇒ defaults to `size`. */
+  max: number | null
+  /** How long an idle pooled container is kept before eviction (ms). */
+  idleTtlMs: number
+}
+
+export interface LocalCheckoutSettings {
+  /** Absolute in-container dir the reused per-repo checkout lives under. */
+  workspaceRoot: string
+  /** Dep-cache directories the per-run clean sweep keeps (so deps aren't reinstalled). */
+  cleanKeep: string[]
+}
+
+export interface LocalSettings {
+  pool: LocalPoolSettings
+  checkout: LocalCheckoutSettings
+}
+
+/** Admin write: the full settings blob fully replaces the stored config. */
+export type UpdateLocalSettingsInput = LocalSettings