@cat-factory/app 0.36.0 → 0.37.1

package/app/types/accountSettings.ts

@@ -1,39 +1,14 @@
 // Per-account (deployment-wide) integration settings. Mirrors
 // `@cat-factory/contracts` accountSettings. Secrets are write-only — the read view
 // returns only `config` + a non-secret presence `summary`.
-
-export interface SlackOAuthSecret {
-  clientId: string
-  clientSecret: string
-  redirectUrl: string
-}
-
-export interface WebSearchSecret {
-  braveApiKey?: string
-  searxngUrl?: string
-  searxngApiKey?: string
-}
-
-/** Non-secret per-account config (empty today; reserved for forward-compatible tuning). */
-export type AccountSettingsConfig = Record<string, never>
-
-export interface AccountSettingsSummary {
-  slackOAuthConfigured: boolean
-  webSearch: 'brave' | 'searxng' | null
-}
-
-export interface AccountSettingsView {
-  config: AccountSettingsConfig
-  summary: AccountSettingsSummary
-}
-
-/**
- * Admin write. Each secrets group: omit ⇒ leave unchanged, `null` ⇒ clear, value ⇒ set.
- */
-export interface UpdateAccountSettingsInput {
-  config?: AccountSettingsConfig
-  secrets?: {
-    slackOAuth?: SlackOAuthSecret | null
-    webSearch?: WebSearchSecret | null
-  }
-}
+//
+// All wire shapes are sourced from @cat-factory/contracts (single source of truth).
+
+export type {
+  SlackOAuthSecret,
+  WebSearchSecret,
+  AccountSettingsConfig,
+  AccountSettingsSummary,
+  AccountSettingsView,
+  UpdateAccountSettingsInput,
+} from '@cat-factory/contracts'

package/app/types/accounts.ts

@@ -4,74 +4,19 @@
 // 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
-}
+//
+// All wire shapes are sourced from @cat-factory/contracts (single source of truth).
+
+export type {
+  AccountType,
+  AccountRole,
+  Account,
+  AccountMember,
+  CreateAccountInput,
+  UpdateAccountInput,
+  AddMemberInput,
+  SetMemberRolesInput,
+  AccountInvitation,
+  EmailProviderKind,
+  EmailConnection,
+} from '@cat-factory/contracts'

package/app/types/bootstrap.ts

@@ -6,78 +6,16 @@
 // 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
-}
+//
+// All wire shapes are sourced from @cat-factory/contracts (single source of truth).
+
+export type {
+  ReferenceArchitecture,
+  CreateReferenceArchitectureInput,
+  UpdateReferenceArchitectureInput,
+  BootstrapStatus,
+  BootstrapFailureKind,
+  BootstrapFailure,
+  BootstrapJob,
+  BootstrapRepoInput,
+} from '@cat-factory/contracts'

package/app/types/brainstorm.ts

@@ -10,46 +10,21 @@
 // Structurally identical to a requirements review (the items share the same shape), so the
 // per-item types are reused from `~/types/requirements`; only the `stage` discriminator and
 // the converged document (`convergedDirection`) differ.
+//
+// All wire shapes are sourced from @cat-factory/contracts (single source of truth).
 
-import type {
-  RequirementReviewItem,
+export type {
+  BrainstormStage,
+  BrainstormItem,
+  BrainstormStatus,
+  ResolveBrainstormExceededChoice,
+  BrainstormSession,
+  // The per-item types are shared with a requirements review (same shape).
   ReviewItemCategory,
   ReviewItemSeverity,
   ReviewItemStatus,
-} from '~/types/requirements'
-
-export type { ReviewItemCategory, ReviewItemSeverity, ReviewItemStatus }
-
-/** Which dialogue a brainstorm session drives. */
-export type BrainstormStage = 'requirements' | 'architecture'
-
-/** A brainstorm option is the same shape as a requirements-review item. */
-export type BrainstormItem = RequirementReviewItem
-
-/** Lifecycle of a brainstorm session — identical to the requirements review lifecycle. */
-export type BrainstormStatus =
-  | 'ready'
-  | 'incorporating'
-  | 'reviewing'
-  | 'merged'
-  | 'exceeded'
-  | 'incorporated'
-
-/** How a human resolves a session that hit its iteration cap. */
-export type ResolveBrainstormExceededChoice = 'extra-round' | 'proceed' | 'stop-reset'
+} from '@cat-factory/contracts'
+import type { UpdateBrainstormItemStatusInput } from '@cat-factory/contracts'
 
-export interface BrainstormSession {
-  id: string
-  blockId: string
-  stage: BrainstormStage
-  status: BrainstormStatus
-  items: BrainstormItem[]
-  model: string | null
-  convergedDirection: string | null
-  /** Agent passes run so far (initial pass is 1; each re-run adds one). */
-  iteration: number
-  /** The agent-pass budget (from the task's merge preset; an extra round bumps it). */
-  maxIterations: number
-  createdAt: number
-  updatedAt: number
-}
+/** The narrower status set the set-item-status action accepts (a subset of ReviewItemStatus). */
+export type BrainstormItemStatus = UpdateBrainstormItemStatusInput['status']

package/app/types/clarity.ts

@@ -9,51 +9,20 @@
 // 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`).
+//
+// All wire shapes are sourced from @cat-factory/contracts (single source of truth).
 
-import type {
-  RequirementReviewItem,
+export type {
+  ClarityReviewItem,
+  ClarityReviewStatus,
+  ResolveClarityExceededChoice,
+  ClarityReview,
+  // The per-item types are shared with a requirements review (same shape).
   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'
+} from '@cat-factory/contracts'
+import type { UpdateClarityItemStatusInput } from '@cat-factory/contracts'
 
-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
-}
+/** The narrower status set the set-item-status action accepts (a subset of ReviewItemStatus). */
+export type ClarityItemStatus = UpdateClarityItemStatusInput['status']

package/app/types/consensus.ts

@@ -1,91 +1,18 @@
 // 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
-}
+//
+// All wire shapes are sourced from @cat-factory/contracts (single source of truth).
+
+export type {
+  ConsensusStrategy,
+  ConsensusParticipant,
+  ConsensusGating,
+  StepGating,
+  ConsensusStepConfig,
+  TaskEstimate,
+  ConsensusScore,
+  ConsensusContribution,
+  ConsensusRound,
+  ConsensusSessionStatus,
+  ConsensusSession,
+} from '@cat-factory/contracts'

package/app/types/documents.ts

@@ -1,102 +1,27 @@
 // ---------------------------------------------------------------------------
 // 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`.
+// attached to a task as agent context.
+//
+// All wire shapes are sourced from @cat-factory/contracts (single source of
+// truth). `SpawnResult` has no exported contract type (the contract models it
+// inline), so it stays frontend-only below.
 // ---------------------------------------------------------------------------
 
-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 type {
+  DocumentSourceKind,
+  CredentialField,
+  DocumentSourceDescriptor,
+  DocumentConnection,
+  SourceDocument,
+  DocumentSearchResult,
+  PlanTask,
+  PlanModule,
+  PlanFrame,
+  DocumentBoardPlan,
+} from '@cat-factory/contracts'
+
+/** Counts of blocks created by spawning a plan onto the board. Frontend-only. */
 export interface SpawnResult {
   frames: number
   modules: number