@cat-factory/app 0.6.0

package/app/stores/workspaceSettings.ts

@@ -0,0 +1,36 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { UpdateWorkspaceSettingsInput, WorkspaceSettings } from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/** Built-in defaults, mirrored from the backend's DEFAULT_WORKSPACE_SETTINGS. */
+const DEFAULTS: WorkspaceSettings = {
+  waitingEscalationMinutes: 120,
+  taskLimitMode: 'off',
+  taskLimitShared: null,
+  taskLimitPerType: null,
+}
+
+/**
+ * The workspace's runtime settings — the human-wait escalation threshold (after which a
+ * waiting notification turns red) and the per-service running-task limit policy. Hydrated
+ * from the workspace snapshot; edited via the settings panel. Falls back to the built-in
+ * defaults until the snapshot lands (or on an older server that doesn't send them).
+ */
+export const useWorkspaceSettingsStore = defineStore('workspaceSettings', () => {
+  const api = useApi()
+  const settings = ref<WorkspaceSettings>({ ...DEFAULTS })
+
+  function hydrate(value: WorkspaceSettings | undefined) {
+    settings.value = value ? { ...value } : { ...DEFAULTS }
+  }
+
+  async function update(patch: UpdateWorkspaceSettingsInput) {
+    const ws = useWorkspaceStore()
+    const updated = await api.updateWorkspaceSettings(ws.requireId(), patch)
+    settings.value = updated
+    return updated
+  }
+
+  return { settings, hydrate, update }
+})

package/app/types/accounts.ts

@@ -0,0 +1,77 @@
+// ---------------------------------------------------------------------------
+// Account tenancy. An account owns workspaces (boards): either a single user's
+// `personal` account or an `org` shared by many engineers. Memberships map users
+// to accounts with a role. Mirrors the `@cat-factory/contracts` account schemas
+// so responses drop straight into the Pinia store.
+// ---------------------------------------------------------------------------
+
+import type { CloudProvider } from './domain'
+
+export type AccountType = 'personal' | 'org'
+/** Combinable account roles: admin controls the org account, product owns tasks. */
+export type AccountRole = 'admin' | 'developer' | 'product'
+
+/** An account, annotated with the signed-in caller's roles in it. */
+export interface Account {
+  id: string
+  type: AccountType
+  name: string
+  githubAccountLogin: string | null
+  createdAt: number
+  /** The caller's roles in this account (`null` in the auth-disabled path). */
+  roles: AccountRole[] | null
+  /** The cloud provider new services in this account default to; absent = built-in default. */
+  defaultCloudProvider?: CloudProvider
+}
+
+/** A member of an account, with display details when resolvable. */
+export interface AccountMember {
+  accountId: string
+  userId: string
+  roles: AccountRole[]
+  createdAt: number
+  name?: string | null
+  email?: string | null
+  avatarUrl?: string | null
+}
+
+export interface CreateAccountInput {
+  name: string
+  githubAccountLogin?: string
+}
+
+/** Update an account's settings (today: its default cloud provider for new services). */
+export interface UpdateAccountInput {
+  defaultCloudProvider?: CloudProvider
+}
+
+export interface AddMemberInput {
+  userId: string
+  roles?: AccountRole[]
+}
+
+/** Set a member's role set (admin-only). */
+export interface SetMemberRolesInput {
+  roles: AccountRole[]
+}
+
+/** An email invitation into an org account (never carries the raw token). */
+export interface AccountInvitation {
+  id: string
+  accountId: string
+  email: string
+  roles: AccountRole[]
+  status: 'pending' | 'accepted' | 'revoked'
+  invitedBy: string
+  expiresAt: number
+  createdAt: number
+}
+
+export type EmailProviderKind = 'sendgrid' | 'resend'
+
+/** A per-account email-sender connection (safe metadata; never the API key). */
+export interface EmailConnection {
+  provider: EmailProviderKind
+  fromAddress: string
+  connectedAt: number
+}

package/app/types/bootstrap.ts

@@ -0,0 +1,83 @@
+// ---------------------------------------------------------------------------
+// Repo-bootstrap domain types. Mirrors the `@cat-factory/contracts` bootstrap
+// schemas so backend payloads drop straight into the Pinia store.
+//
+// A "reference architecture" is a managed base repo (an opinionated starter the
+// org wants new services to follow); the "bootstrap repo" task creates a new repo
+// from one and runs a bootstrapper agent in a container to adapt it.
+// ---------------------------------------------------------------------------
+
+import type { AgentFailure, AgentFailureKind, StepSubtasks } from './execution'
+
+/** A managed base repository new repos are bootstrapped from. */
+export interface ReferenceArchitecture {
+  id: string
+  workspaceId: string
+  name: string
+  description: string
+  repoOwner: string
+  repoName: string
+  defaultInstructions: string
+  createdAt: number
+  updatedAt: number
+}
+
+/** Body to register a reference architecture. */
+export interface CreateReferenceArchitectureInput {
+  name: string
+  description?: string
+  repoOwner: string
+  repoName: string
+  defaultInstructions?: string
+}
+
+/** Body to patch a reference architecture (only supplied fields change). */
+export type UpdateReferenceArchitectureInput = Partial<CreateReferenceArchitectureInput>
+
+/** Lifecycle of a single "bootstrap repo" run. */
+export type BootstrapStatus = 'pending' | 'running' | 'succeeded' | 'failed'
+
+/**
+ * A bootstrap run's failure is now the shared {@link AgentFailure} (same shape
+ * execution runs use), so the board renders one failure banner + retry for any
+ * agent. These aliases stay for back-compat / documentation of the bootstrap
+ * subset; `bootstrapFailureKindSchema` on the backend stays narrow.
+ */
+export type BootstrapFailureKind = AgentFailureKind
+
+/** Structured failure diagnostics captured when a bootstrap run fails. */
+export type BootstrapFailure = AgentFailure
+
+/** One "bootstrap repo" run with its outcome. */
+export interface BootstrapJob {
+  id: string
+  workspaceId: string
+  /** Reference architecture the run was based on, or null for a from-scratch run. */
+  referenceArchitectureId: string | null
+  /** Denormalized reference architecture name, or null for a from-scratch run. */
+  referenceArchitectureName: string | null
+  repoName: string
+  repoOwner: string | null
+  repoUrl: string | null
+  instructions: string
+  status: BootstrapStatus
+  /** The board service frame this run materialises, or null if none was created. */
+  blockId: string | null
+  /** Live subtask counts from the bootstrapper agent, or null until it reports. */
+  subtasks: StepSubtasks | null
+  error: string | null
+  /** Structured failure diagnostics when `status` is `failed`; null otherwise. */
+  failure: BootstrapFailure | null
+  createdAt: number
+  updatedAt: number
+}
+
+/** Body to kick off a bootstrap run. Omit `referenceArchitectureId` to bootstrap
+ * from a freeform prompt alone (then `instructions` must be non-empty). */
+export interface BootstrapRepoInput {
+  referenceArchitectureId?: string | null
+  repoName: string
+  description?: string
+  private?: boolean
+  instructions?: string
+}

package/app/types/clarity.ts

@@ -0,0 +1,59 @@
+// Clarity-review wire types. Mirror of `@cat-factory/contracts`' clarity.ts, kept
+// in sync by hand like the rest of `~/types/*` (the SPA does not import the backend
+// package directly).
+//
+// A stateless reviewer agent triages a block's BUG REPORT for fixability — raising
+// questions / gaps / clarifications about the report; a human answers or dismisses
+// each; then the agent folds the answers back into a clarified bug report.
+//
+// Structurally identical to a requirements review (the items share the same shape),
+// so the per-item types are reused from `~/types/requirements`; only the
+// incorporated document differs (`clarifiedReport`).
+
+import type {
+  RequirementReviewItem,
+  ReviewItemCategory,
+  ReviewItemSeverity,
+  ReviewItemStatus,
+} from '~/types/requirements'
+
+export type { ReviewItemCategory, ReviewItemSeverity, ReviewItemStatus }
+
+/** A clarity-review item is the same shape as a requirements-review item. */
+export type ClarityReviewItem = RequirementReviewItem
+
+/**
+ * - `ready`: the reviewer raised findings awaiting human answers/dismissals.
+ * - `incorporating`: transient; the driver is folding the answers into a document (the FIRST
+ *   async stage — the user is back on the board).
+ * - `reviewing`: transient; the reviewer is RE-reviewing the folded document (the SECOND
+ *   async stage). Distinct from `incorporating` so the UI can show which stage is running.
+ * - `merged`: the companion produced a document (an internal transient on the async path).
+ * - `exceeded`: the iteration cap was hit with findings open — awaiting the human's choice.
+ * - `incorporated`: terminal; the clarity phase is settled.
+ */
+export type ClarityReviewStatus =
+  | 'ready'
+  | 'incorporating'
+  | 'reviewing'
+  | 'merged'
+  | 'exceeded'
+  | 'incorporated'
+
+/** How a human resolves a review that hit its iteration cap. */
+export type ResolveClarityExceededChoice = 'extra-round' | 'proceed' | 'stop-reset'
+
+export interface ClarityReview {
+  id: string
+  blockId: string
+  status: ClarityReviewStatus
+  items: ClarityReviewItem[]
+  model: string | null
+  clarifiedReport: string | null
+  /** Reviewer passes run so far (initial review is 1; each re-review adds one). */
+  iteration: number
+  /** The reviewer-pass budget (from the task's merge preset; an extra round bumps it). */
+  maxIterations: number
+  createdAt: number
+  updatedAt: number
+}

package/app/types/consensus.ts

@@ -0,0 +1,91 @@
+// Frontend mirror of the consensus + task-estimate wire contracts in
+// `@cat-factory/contracts` (src/consensus.ts). Hand-synced, like the other type mirrors.
+
+export type ConsensusStrategy = 'specialist-panel' | 'debate' | 'ranked-voting'
+
+export interface ConsensusParticipant {
+  id: string
+  role: string
+  systemFraming?: string
+  modelId?: string
+}
+
+export interface ConsensusGating {
+  enabled: boolean
+  minComplexity?: number
+  minRisk?: number
+  minImpact?: number
+  onMissingEstimate?: 'consensus' | 'standard'
+}
+
+/**
+ * Estimate-based gating of whether a pipeline STEP runs at all (the same three axes as
+ * {@link ConsensusGating}). When enabled the step runs only if ANY supplied axis is met or
+ * exceeded; otherwise it is skipped at runtime. Used to make a companion conditional on how
+ * heavy the task is. A step with enabled gating requires a `task-estimator` earlier in the
+ * pipeline.
+ */
+export interface StepGating {
+  enabled: boolean
+  minComplexity?: number
+  minRisk?: number
+  minImpact?: number
+  onMissingEstimate?: 'run' | 'skip'
+}
+
+export interface ConsensusStepConfig {
+  enabled: boolean
+  strategy: ConsensusStrategy
+  participants: ConsensusParticipant[]
+  synthesizerModelId?: string
+  rounds?: number
+  gating?: ConsensusGating
+}
+
+/** The task-estimator's triage of a task (each axis 0..1). */
+export interface TaskEstimate {
+  complexity: number
+  risk: number
+  impact: number
+  rationale: string
+  model?: string | null
+  createdAt: number
+}
+
+export interface ConsensusScore {
+  dimension: string
+  value: number
+  rationale?: string
+}
+
+export interface ConsensusContribution {
+  participantId: string
+  text: string
+  scores?: ConsensusScore[]
+}
+
+export interface ConsensusRound {
+  index: number
+  kind?: 'draft' | 'critique' | 'score'
+  contributions: ConsensusContribution[]
+}
+
+export type ConsensusSessionStatus = 'running' | 'synthesizing' | 'done' | 'failed'
+
+export interface ConsensusSession {
+  id: string
+  blockId: string
+  executionId: string | null
+  stepIndex: number
+  agentKind: string
+  strategy: ConsensusStrategy
+  status: ConsensusSessionStatus
+  participants: ConsensusParticipant[]
+  rounds: ConsensusRound[]
+  synthesis: string | null
+  confidence?: number | null
+  dissent?: string[]
+  error?: string | null
+  createdAt: number
+  updatedAt: number
+}

package/app/types/documents.ts

@@ -0,0 +1,104 @@
+// ---------------------------------------------------------------------------
+// Document-source integration. Requirements / RFCs / PRDs imported from external
+// sources (Confluence, Notion, …) can be expanded into board structure or
+// attached to a task as agent context. These mirror the `@cat-factory/contracts`
+// document schemas; the abstraction is source-agnostic, keyed by `source`.
+// ---------------------------------------------------------------------------
+
+import type { BlockType } from './domain'
+
+/** The external document sources cat-factory can link to. */
+export type DocumentSourceKind = 'confluence' | 'notion' | 'github'
+
+/** One credential a provider needs to connect (rendered as a form field). */
+export interface CredentialField {
+  key: string
+  label: string
+  help?: string
+  placeholder?: string
+  secret?: boolean
+}
+
+/** A source's self-description: drives the generic connect + import UI. */
+export interface DocumentSourceDescriptor {
+  source: DocumentSourceKind
+  label: string
+  /** Lucide icon name for the source. */
+  icon: string
+  credentialFields: CredentialField[]
+  refLabel: string
+  refPlaceholder: string
+  /** Whether the source supports searching its catalogue by title/content. */
+  searchable?: boolean
+}
+
+/** A workspace's connection to a document source (never carries credentials). */
+export interface DocumentConnection {
+  source: DocumentSourceKind
+  /** Human-friendly label for what we're connected to (site URL, workspace name). */
+  label: string
+  /** When the connection was established (epoch ms). */
+  connectedAt: number
+}
+
+/** A page imported from a source into the workspace. */
+export interface SourceDocument {
+  source: DocumentSourceKind
+  /** The source's stable id for the page. */
+  externalId: string
+  title: string
+  url: string
+  /** Short plain-text preview of the page body. */
+  excerpt: string
+  /** The board block this document is attached to as context, if any. */
+  linkedBlockId: string | null
+  syncedAt: number
+}
+
+/** A lean hit from searching a document source's catalogue (not yet imported). */
+export interface DocumentSearchResult {
+  source: DocumentSourceKind
+  /** The source's stable id for the page (re-usable as an import ref). */
+  externalId: string
+  title: string
+  url: string
+  /** Short plain-text preview (may be empty). */
+  excerpt: string
+}
+
+/** A proposed task within a planned frame/module. */
+export interface PlanTask {
+  title: string
+  description?: string
+}
+
+/** A proposed module grouping tasks within a planned frame. */
+export interface PlanModule {
+  name: string
+  tasks: PlanTask[]
+}
+
+/** A proposed top-level frame with its modules and loose tasks. */
+export interface PlanFrame {
+  type: BlockType
+  title: string
+  description?: string
+  modules: PlanModule[]
+  tasks: PlanTask[]
+}
+
+/** A board structure extracted from an imported document. */
+export interface DocumentBoardPlan {
+  source: DocumentSourceKind
+  externalId: string
+  /** Whether an LLM produced the plan or the deterministic heading parser did. */
+  planner: 'llm' | 'headings'
+  frames: PlanFrame[]
+}
+
+/** Counts of blocks created by spawning a plan onto the board. */
+export interface SpawnResult {
+  frames: number
+  modules: number
+  tasks: number
+}