studiograph 1.2.0-beta.9 → 1.2.1

package/dist/core/validation.js

@@ -1,8 +1,13 @@
 /**
  * Entity validation schemas for Studiograph
  *
- * Based on real-world templates from Schema Design's Obsidian vault,
- * generalized for use by any creative service firm.
+ * 17 built-in entity types organized into three categories:
+ * - Identity (4): person, organization, role, practice-area
+ * - Universal (10): project, meeting, decision, task, document, dataset, reference, note, deliverable, publication
+ * - Knowledge (3): process, standard, case-study
+ *
+ * App plugins register additional types at runtime via SchemaRegistry.
+ * Teams can define custom types via schema_extensions in workspace config.
  */
 import { z } from 'zod';
 /**
@@ -17,305 +22,255 @@ export const EntityBaseSchema = z.object({
     updated_at: z.string().datetime('Invalid datetime format'),
     created_by: z.string().min(1, 'Created by is required'),
     updated_by: z.string().min(1, 'Updated by is required'),
-    visibility: z.enum(['public', 'team', 'admin', 'restricted'])
-        .default('team')
-        .describe('Access level for this entity'),
-    restricted_to: z.array(z.string())
-        .optional()
-        .describe('User IDs with access (if visibility=restricted)'),
-    sensitive_fields: z.array(z.string())
-        .optional()
-        .describe('Fields that contain sensitive data'),
     tags: z.array(z.string())
         .optional()
         .describe('Tags for categorization'),
 }).passthrough(); // Allow custom fields beyond the base schema
+// ══════════════════════════════════════════════════════════════════════════════
+// IDENTITY ENTITIES — people, organizations, roles, practice areas
+// ══════════════════════════════════════════════════════════════════════════════
+/**
+ * Person — team members, client contacts, any individual
+ */
+export const PersonSchema = EntityBaseSchema.extend({
+    entity_type: z.literal('person'),
+    name: z.string().min(1, 'Person name is required'),
+    role: z.string().optional().describe('Role or title'),
+    status: z.enum(['current', 'former', 'contractor', 'client', 'partner'])
+        .optional()
+        .describe('Relationship status'),
+    email: z.string().optional().describe('Email address'),
+    location: z.string().optional().describe('Location'),
+    organization: z.string().optional().describe('Organization wikilink'),
+    bio: z.string().optional().describe('Biography (markdown)'),
+    projects: z.array(z.string()).optional().describe('Related project wikilinks'),
+    reports_to: z.string().optional().describe('Manager or role wikilink'),
+    department: z.string().optional().describe('Department'),
+});
+/**
+ * Organization — clients, vendors, partners, prospects, industry bodies
+ * Replaces the former separate client and vendor types.
+ */
+export const OrganizationSchema = EntityBaseSchema.extend({
+    entity_type: z.literal('organization'),
+    name: z.string().min(1, 'Organization name is required'),
+    type: z.enum(['client', 'vendor', 'partner', 'prospect', 'industry-body', 'other'])
+        .optional()
+        .describe('Relationship type'),
+    status: z.enum(['active', 'inactive', 'prospect', 'former'])
+        .default('active')
+        .describe('Organization status'),
+    industry: z.string().optional().describe('Industry sector'),
+    website: z.string().url().optional().describe('Website URL'),
+    location: z.string().optional().describe('Primary location'),
+    size: z.enum(['small', 'medium', 'large', 'enterprise'])
+        .optional()
+        .describe('Organization size'),
+    contacts: z.array(z.string()).optional().describe('Contact person wikilinks'),
+    projects: z.array(z.string()).optional().describe('Related project wikilinks'),
+    relationship_start: z.string().optional().describe('When the relationship started'),
+});
 /**
- * PROJECT REPO ENTITIES
- * Used in project-specific repositories (one per client/project)
+ * Role — role definitions from the firm's leveling framework
  */
+export const RoleSchema = EntityBaseSchema.extend({
+    entity_type: z.literal('role'),
+    title: z.string().min(1, 'Role title is required'),
+    department: z.string().optional().describe('Department'),
+    level: z.number().optional().describe('Level 1–5 from leveling framework'),
+    type: z.enum(['staff', 'contractor', 'intern'])
+        .optional()
+        .describe('Employment type'),
+    status: z.enum(['active', 'archived'])
+        .default('active')
+        .describe('Role status'),
+    location: z.string().optional().describe('Location'),
+    reports_to: z.string().optional().describe('Parent role or person wikilink'),
+});
 /**
- * Project entity - represents a client engagement or internal initiative
+ * Practice Area — firm capabilities and disciplines
+ */
+export const PracticeAreaSchema = EntityBaseSchema.extend({
+    entity_type: z.literal('practice-area'),
+    name: z.string().min(1, 'Practice area name is required'),
+    description: z.string().optional().describe('Overview of the discipline'),
+    capabilities: z.array(z.string()).optional().describe('Specific service offerings'),
+    related_case_studies: z.array(z.string()).optional().describe('Case study wikilinks'),
+    related_projects: z.array(z.string()).optional().describe('Related project wikilinks'),
+});
+// ══════════════════════════════════════════════════════════════════════════════
+// UNIVERSAL ENTITIES — available in any repo
+// ══════════════════════════════════════════════════════════════════════════════
+/**
+ * Project — a client engagement or internal initiative
+ * Subtypes via `type` field: client-project, internal-initiative, event, research
  */
 export const ProjectSchema = EntityBaseSchema.extend({
     entity_type: z.literal('project'),
     name: z.string().min(1, 'Project name is required'),
-    client: z.string().optional().describe('Client name or wikilink'),
+    type: z.string().optional().describe('Project subtype (e.g., client-project, internal-initiative, event, research)'),
+    client: z.string().optional().describe('Client organization wikilink'),
     website_url: z.string().url().optional().describe('Project website URL'),
-    start_date: z.string().optional().describe('Project start date (ISO 8601 or human-readable)'),
+    start_date: z.string().optional().describe('Project start date'),
     end_date: z.string().optional().describe('Project end date'),
-    target_completion: z.string().optional().describe('Target completion date'),
-    year_released: z.number().optional().describe('Year the project was released'),
     status: z.enum(['planning', 'scoping', 'active', 'on-hold', 'completed', 'archived'])
         .optional()
         .describe('Current project status'),
     related_projects: z.array(z.string()).optional().describe('Related project wikilinks'),
-    related_areas: z.array(z.string()).optional().describe('Practice areas (e.g., [[Data Visualization]])'),
+    related_areas: z.array(z.string()).optional().describe('Practice area wikilinks'),
     team: z.array(z.string()).optional().describe('Team member wikilinks'),
-    deliverables: z.array(z.string()).optional().describe('Project deliverables'),
+    deliverables: z.array(z.string()).optional().describe('Deliverable wikilinks'),
     deal: z.string().optional().describe('Originating deal wikilink'),
 });
 /**
- * Meeting entity - captures meeting notes, decisions, and action items
+ * Meeting — any scheduled gathering
+ * Subtypes via `type` field: internal, client, workshop, conference, industry-event
  */
 export const MeetingSchema = EntityBaseSchema.extend({
     entity_type: z.literal('meeting'),
     name: z.string().min(1, 'Meeting name/subject is required'),
-    date: z.string().optional().describe('Meeting date (ISO 8601 or human-readable)'),
-    attendees: z.array(z.string()).optional().describe('Attendee names or wikilinks'),
+    type: z.string().optional().describe('Meeting subtype (e.g., internal, client, workshop, conference, industry-event)'),
+    date: z.string().optional().describe('Meeting date'),
+    attendees: z.array(z.string()).optional().describe('Attendee wikilinks'),
     related_projects: z.array(z.string()).optional().describe('Related project wikilinks'),
     related_organizations: z.array(z.string()).optional().describe('Related organization wikilinks'),
     related_areas: z.array(z.string()).optional().describe('Practice area wikilinks'),
     agenda: z.string().optional().describe('Meeting agenda (markdown)'),
-    notes: z.string().optional().describe('Meeting notes (markdown)'),
     action_items: z.array(z.string()).optional().describe('Action items from the meeting'),
     summary: z.string().optional().describe('Meeting summary'),
 });
 /**
- * Decision entity - structured decision records (ADR-style)
- * Format: DEC-YYYY-NNN
+ * Decision — structured decision records (ADR-style)
  */
 export const DecisionSchema = EntityBaseSchema.extend({
     entity_type: z.literal('decision'),
-    id: z.string()
-        .regex(/^DEC-\d{4}-\d{3}$/, 'Decision ID must be in format DEC-YYYY-NNN')
-        .describe('Unique decision identifier'),
     title: z.string().min(1, 'Decision title is required'),
-    date: z.string().describe('Decision date (ISO 8601 or human-readable)'),
+    date: z.string().optional().describe('Decision date'),
     status: z.enum(['proposed', 'accepted', 'rejected', 'deprecated', 'superseded'])
         .default('proposed')
-        .describe('Current status of the decision'),
-    decision_makers: z.array(z.string())
-        .optional()
-        .describe('People who made the decision'),
-    stakeholders: z.array(z.string())
-        .optional()
-        .describe('People affected by the decision'),
-    related_decisions: z.array(z.string())
-        .optional()
-        .describe('Related decision wikilinks'),
-    supersedes: z.string()
-        .optional()
-        .describe('Decision this one replaces (wikilink)'),
-    superseded_by: z.string()
-        .optional()
-        .describe('Decision that replaces this one (wikilink)'),
-    context: z.string()
-        .optional()
-        .describe('Background and why this decision was needed'),
-    alternatives: z.string()
-        .optional()
-        .describe('Alternatives considered (markdown)'),
-    decision: z.string()
-        .optional()
-        .describe('The actual decision made'),
-    rationale: z.string()
-        .optional()
-        .describe('Why this decision was chosen'),
-    consequences: z.string()
-        .optional()
-        .describe('Positive/negative outcomes and risks'),
-    enables: z.array(z.string())
-        .optional()
-        .describe('Decisions this one enables'),
+        .describe('Current status'),
+    decision_makers: z.array(z.string()).optional().describe('People who made the decision'),
+    stakeholders: z.array(z.string()).optional().describe('People affected'),
+    context: z.string().optional().describe('Background and why this decision was needed'),
+    alternatives: z.string().optional().describe('Alternatives considered (markdown)'),
+    decision: z.string().optional().describe('The actual decision made'),
+    rationale: z.string().optional().describe('Why this decision was chosen'),
+    consequences: z.string().optional().describe('Outcomes and risks'),
+    supersedes: z.string().optional().describe('Decision this one replaces (wikilink)'),
+    superseded_by: z.string().optional().describe('Decision that replaces this one (wikilink)'),
 });
 /**
- * Task entity - lightweight action items and to-dos
+ * Task — lightweight action items and to-dos
  */
 export const TaskSchema = EntityBaseSchema.extend({
     entity_type: z.literal('task'),
     name: z.string().min(1, 'Task name is required'),
-    assignee: z.string()
-        .optional()
-        .describe('Person assigned to this task (wikilink)'),
-    due_date: z.string()
-        .optional()
-        .describe('Due date (ISO 8601 or human-readable)'),
+    assignee: z.string().optional().describe('Person assigned (wikilink)'),
+    due_date: z.string().optional().describe('Due date'),
     status: z.enum(['open', 'in-progress', 'done', 'cancelled'])
         .default('open')
-        .describe('Current status of the task'),
+        .describe('Task status'),
     priority: z.enum(['low', 'medium', 'high', 'urgent'])
         .optional()
-        .describe('Task priority level'),
-    project: z.string()
-        .optional()
-        .describe('Related project (wikilink)'),
-    deliverable: z.string()
-        .optional()
-        .describe('Related deliverable (wikilink)'),
-    related_meeting: z.string()
-        .optional()
-        .describe('Meeting this task came from (wikilink)'),
-    description: z.string()
-        .optional()
-        .describe('Detailed description of the task'),
+        .describe('Priority level'),
+    project: z.string().optional().describe('Related project (wikilink)'),
+    deliverable: z.string().optional().describe('Related deliverable (wikilink)'),
+    related_meeting: z.string().optional().describe('Meeting this task came from (wikilink)'),
+    description: z.string().optional().describe('Detailed description'),
 });
 /**
- * Brief entity - project briefs and requirements
+ * Document — any authored document
+ * Subtypes via `type` field: proposal, contract, brief, memo, financial-plan, template, report
+ * Absorbs the former separate proposal, contract, brief, financial-plan, and template types.
  */
-export const BriefSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('brief'),
-    project_name: z.string().min(1, 'Project name is required'),
-    client: z.string().optional().describe('Client name or wikilink'),
-    start_date: z.string().optional().describe('Project start date'),
-    target_completion: z.string().optional().describe('Target completion date'),
-    status: z.enum(['planning', 'approved', 'in-progress', 'completed'])
-        .default('planning')
-        .describe('Brief status'),
-    objectives: z.array(z.string()).optional().describe('Project objectives'),
-    target_users: z.string().optional().describe('Target users/audience'),
-    success_criteria: z.array(z.string()).optional().describe('Success criteria'),
-    constraints: z.string().optional().describe('Constraints (timeline, budget, technical)'),
-    stakeholders: z.array(z.string()).optional().describe('Key stakeholder wikilinks'),
-    deliverables: z.array(z.string()).optional().describe('Expected deliverables'),
+export const DocumentSchema = EntityBaseSchema.extend({
+    entity_type: z.literal('document'),
+    name: z.string().min(1, 'Document name is required'),
+    type: z.string().optional().describe('Document subtype (e.g., proposal, contract, brief, memo, financial-plan, template, report)'),
+    client: z.string().optional().describe('Client organization wikilink'),
+    project: z.string().optional().describe('Related project wikilink'),
+    date: z.string().optional().describe('Document date'),
+    version: z.string().optional().describe('Version (e.g., v1, v2)'),
+    status: z.enum(['draft', 'sent', 'accepted', 'rejected', 'negotiating', 'signed', 'completed', 'terminated'])
+        .default('draft')
+        .describe('Document status'),
+    description: z.string().optional().describe('Description or summary'),
+});
+/**
+ * Dataset — structured tabular data with typed columns and CSV body
+ */
+export const ColumnDefinitionSchema = z.object({
+    name: z.string().min(1),
+    type: z.enum(['string', 'number', 'boolean', 'date']),
+    required: z.boolean().optional(),
+    description: z.string().optional(),
+});
+export const DatasetSchema = EntityBaseSchema.extend({
+    entity_type: z.literal('dataset'),
+    name: z.string().min(1, 'Dataset name is required'),
+    schema: z.array(ColumnDefinitionSchema).min(1, 'At least one column required'),
+});
+/**
+ * Reference — external resources and inspiration
+ * Subtypes via `type` field: article, video, tool, technique, framework, website
+ * Absorbs the former separate technique type.
+ */
+export const ReferenceSchema = EntityBaseSchema.extend({
+    entity_type: z.literal('reference'),
+    name: z.string().min(1, 'Reference name is required'),
+    type: z.string().optional().describe('Reference subtype (e.g., article, video, tool, technique, framework, website)'),
+    date: z.string().optional().describe('Publication date'),
+    source: z.string().optional().describe('Source/author'),
+    link: z.string().optional().describe('URL'),
     related_projects: z.array(z.string()).optional().describe('Related project wikilinks'),
+    related_areas: z.array(z.string()).optional().describe('Related practice areas'),
+    description: z.string().optional().describe('Description'),
 });
 /**
- * Artifact entity - deliverables and project outputs
+ * Note — freeform thinking, research, scratch, daily notes
+ * Lightweight entity with minimal schema. Participates in the graph like any other entity.
  */
-export const ArtifactSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('artifact'),
-    name: z.string().min(1, 'Artifact name is required'),
-    type: z.string()
-        .optional()
-        .describe('Artifact type (e.g., presentation, prototype, report, design-file)'),
-    project: z.string().optional().describe('Related project wikilink'),
-    deliverable: z.string().optional().describe('Parent deliverable wikilink'),
-    date_created: z.string().optional().describe('Creation date'),
-    description: z.string().optional().describe('Artifact description'),
-    url: z.string().optional().describe('URL or file path'),
-    version: z.string().optional().describe('Version number'),
+export const NoteSchema = EntityBaseSchema.extend({
+    entity_type: z.literal('note'),
+    title: z.string().optional().describe('Note title'),
+    type: z.string().optional().describe('Note subtype (e.g., research, scratch, daily, brainstorm, draft)'),
+    related_projects: z.array(z.string()).optional().describe('Related project wikilinks'),
+    related_organizations: z.array(z.string()).optional().describe('Related organization wikilinks'),
 });
 /**
- * Deliverable entity - a scoped, contractual output promised to a client
- *
- * Operates at a higher level than individual artifacts: a deliverable is the
- * "big ticket item" committed to in a proposal or contract (e.g. "Brand
- * Identity System"), while artifacts are the individual produced items within
- * it (logo SVG, style guide PDF, brand guidelines deck).
- *
- * Bridges the commercial side (proposal, contract) to the execution side
- * (artifact): proposal.deliverables[] → deliverable → artifact[]
+ * Deliverable — a scoped contractual output promised to a client
+ * Bridges the commercial side (proposal, contract) to execution (artifacts, tasks).
  */
 export const DeliverableSchema = EntityBaseSchema.extend({
     entity_type: z.literal('deliverable'),
     name: z.string().min(1, 'Deliverable name is required'),
     project: z.string().optional().describe('Related project wikilink'),
-    proposal: z.string().optional().describe('Originating proposal wikilink'),
-    contract: z.string().optional().describe('Formalizing contract wikilink'),
-    artifacts: z.array(z.string()).optional().describe('Component artifact wikilinks'),
     status: z.enum(['planned', 'in-progress', 'delivered', 'accepted', 'rejected'])
         .default('planned')
         .describe('Delivery status'),
-    due_date: z.string().optional().describe('Due date (ISO 8601 or human-readable)'),
+    due_date: z.string().optional().describe('Due date'),
     delivered_date: z.string().optional().describe('Actual delivery date'),
     description: z.string().optional().describe('What this deliverable comprises'),
 });
 /**
- * FUNCTION REPO ENTITIES
- * Used in function-specific repositories (business operations)
- */
-/**
- * Proposal entity - client proposals and SOWs
+ * Publication — authored content published externally
+ * Subtypes via `type` field: article, social-post, case-study-writeup, talk, podcast, award-submission
  */
-export const ProposalSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('proposal'),
-    name: z.string().min(1, 'Proposal name is required'),
-    client: z.string().optional().describe('Client name or wikilink'),
-    project_name: z.string().optional().describe('Project name'),
-    date: z.string().optional().describe('Proposal date'),
-    version: z.string().optional().describe('Version (e.g., v1, v2)'),
-    status: z.enum(['draft', 'sent', 'accepted', 'rejected', 'negotiating'])
+export const PublicationSchema = EntityBaseSchema.extend({
+    entity_type: z.literal('publication'),
+    title: z.string().min(1, 'Publication title is required'),
+    type: z.string().optional().describe('Publication subtype (e.g., article, social-post, talk, podcast, award-submission)'),
+    platform: z.string().optional().describe('Platform (e.g., linkedin, medium, behance, conference)'),
+    status: z.enum(['draft', 'review', 'scheduled', 'published'])
         .default('draft')
-        .describe('Proposal status'),
-    deliverables: z.array(z.string()).optional().describe('Proposed deliverables'),
-    phases: z.string().optional().describe('Project phases (markdown)'),
-    team: z.array(z.string()).optional().describe('Proposed team members'),
-    schedule: z.string().optional().describe('Proposed schedule'),
-    fees: z.string().optional().describe('Fee structure'),
-    payment_terms: z.string().optional().describe('Payment terms and schedule'),
-});
-/**
- * Contract entity - SOWs, MSAs, NDAs
- */
-export const ContractSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('contract'),
-    name: z.string().min(1, 'Contract name is required'),
-    type: z.enum(['sow', 'msa', 'nda', 'other'])
-        .optional()
-        .describe('Contract type'),
-    client: z.string().optional().describe('Client name or wikilink'),
-    project: z.string().optional().describe('Related project wikilink'),
-    date_signed: z.string().optional().describe('Signature date'),
-    start_date: z.string().optional().describe('Contract start date'),
-    end_date: z.string().optional().describe('Contract end date'),
-    status: z.enum(['draft', 'pending', 'signed', 'completed', 'terminated'])
-        .default('draft')
-        .describe('Contract status'),
-    value: z.string().optional().describe('Contract value'),
-    payment_terms: z.string().optional().describe('Payment terms'),
-});
-/**
- * Person entity - team members, clients, contacts
- */
-export const PersonSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('person'),
-    name: z.string().min(1, 'Person name is required'),
-    role: z.string().optional().describe('Role or title'),
-    status: z.enum(['current', 'former', 'contractor', 'client', 'partner'])
-        .optional()
-        .describe('Relationship status'),
-    email: z.string().optional().describe('Email address'),
-    location: z.string().optional().describe('Location'),
-    organization: z.string().optional().describe('Organization wikilink'),
-    years_experience: z.number().optional().describe('Years of experience'),
-    bio: z.string().optional().describe('Biography (markdown)'),
-    projects: z.array(z.string()).optional().describe('Related project wikilinks'),
-    reports_to: z.string().optional().describe('Manager or role wikilink'),
-    department: z.string().optional().describe('Department (e.g. Creative Technology, Design)'),
-});
-/**
- * Client entity - client organizations and companies
- */
-export const ClientSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('client'),
-    name: z.string().min(1, 'Client name is required'),
-    type: z.enum(['corporate', 'nonprofit', 'government', 'startup', 'agency', 'other'])
-        .optional()
-        .describe('Organization type'),
-    status: z.enum(['active', 'inactive', 'prospect', 'former'])
-        .default('active')
-        .describe('Client status'),
-    industry: z.string().optional().describe('Industry sector'),
-    website: z.string().url().optional().describe('Website URL'),
-    location: z.string().optional().describe('Primary location'),
-    size: z.enum(['small', 'medium', 'large', 'enterprise'])
-        .optional()
-        .describe('Organization size'),
-    contacts: z.array(z.string()).optional().describe('Related person wikilinks'),
-    projects: z.array(z.string()).optional().describe('Related project wikilinks'),
-    relationship_start: z.string().optional().describe('When the relationship started'),
-    notes: z.string().optional().describe('Additional notes (markdown)'),
-});
-/**
- * Financial Plan entity - budgets, rates, forecasts
- */
-export const FinancialPlanSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('financial-plan'),
-    name: z.string().min(1, 'Financial plan name is required'),
-    type: z.enum(['budget', 'forecast', 'rates', 'compensation'])
-        .optional()
-        .describe('Plan type'),
-    period: z.string().optional().describe('Time period (e.g., Q1 2026, FY2026)'),
-    project: z.string().optional().describe('Related project wikilink'),
-    amounts: z.string().optional().describe('Financial amounts (markdown table)'),
+        .describe('Publication status'),
+    published_date: z.string().optional().describe('Date published'),
+    url: z.string().optional().describe('URL of published content'),
+    related_projects: z.array(z.string()).optional().describe('Related project wikilinks'),
+    related_areas: z.array(z.string()).optional().describe('Related practice area wikilinks'),
 });
 /**
- * Deal entity - pre-project opportunity moving through the sales pipeline
- *
- * Distinct from a project (which is post-signing execution) and from a proposal
- * (which is a document artifact).  Multiple proposals can belong to one deal.
- * When a deal is won, a project is created and linked via project.deal.
+ * Deal — pre-project opportunity in the sales pipeline
  */
 export const DealSchema = EntityBaseSchema.extend({
     entity_type: z.literal('deal'),
@@ -324,77 +279,22 @@ export const DealSchema = EntityBaseSchema.extend({
     contacts: z.array(z.string()).optional().describe('Contact person wikilinks'),
     stage: z.enum(['scoping', 'proposal', 'negotiating', 'won', 'lost'])
         .default('scoping')
-        .describe('Current pipeline stage'),
-    deal_value: z.number().optional().describe('Estimated deal value (USD)'),
+        .describe('Pipeline stage'),
+    deal_value: z.number().optional().describe('Estimated deal value'),
     probability: z.number().min(0).max(100).optional().describe('Win probability 0–100'),
-    expected_close: z.string().optional().describe('Expected close date (ISO 8601 or human-readable)'),
+    expected_close: z.string().optional().describe('Expected close date'),
     source: z.enum(['referral', 'inbound', 'outbound', 'repeat', 'partner', 'other'])
         .optional()
         .describe('How the opportunity originated'),
-    proposals: z.array(z.string()).optional().describe('Related proposal wikilinks'),
+    proposals: z.array(z.string()).optional().describe('Related proposal document wikilinks'),
     project: z.string().optional().describe('Resulting project wikilink (once won)'),
     lost_reason: z.string().optional().describe('Why the deal was lost'),
 });
+// ══════════════════════════════════════════════════════════════════════════════
+// KNOWLEDGE ENTITIES — typically in resource repos
+// ══════════════════════════════════════════════════════════════════════════════
 /**
- * Vendor entity - external suppliers, freelancers, and partners
- */
-export const VendorSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('vendor'),
-    name: z.string().min(1, 'Vendor name is required'),
-    type: z.enum(['freelancer', 'agency', 'supplier', 'platform', 'partner', 'other'])
-        .optional()
-        .describe('Vendor type'),
-    status: z.enum(['active', 'inactive', 'preferred'])
-        .default('active')
-        .describe('Vendor status'),
-    contact_name: z.string().optional().describe('Primary contact name'),
-    email: z.string().optional().describe('Contact email'),
-    website: z.string().url().optional().describe('Vendor website URL'),
-    services: z.array(z.string()).optional().describe('Services provided'),
-    projects: z.array(z.string()).optional().describe('Related project wikilinks'),
-    notes: z.string().optional().describe('Additional notes (markdown)'),
-});
-/**
- * Role entity - generalized role definitions from the firm's leveling framework
- *
- * Body markdown holds: Role Overview, Key Responsibilities,
- * Leveling Criteria (pillars), Required Skills.
- */
-export const RoleSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('role'),
-    title: z.string().min(1, 'Role title is required'),
-    department: z.string().optional().describe('Department (e.g. Creative Technology, Design)'),
-    level: z.number().optional().describe('Level 1–5 from leveling framework'),
-    type: z.enum(['staff', 'contractor', 'intern'])
-        .optional()
-        .describe('Employment type'),
-    status: z.enum(['active', 'archived'])
-        .default('active')
-        .describe('Role status'),
-    location: z.string().optional().describe('Location'),
-    reports_to: z.string().optional().describe('Parent role or person wikilink'),
-});
-/**
- * SHARED RESOURCE REPO ENTITIES
- * Used in shared knowledge repositories
- */
-/**
- * Template entity - document templates and boilerplates
- */
-export const TemplateSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('template'),
-    name: z.string().min(1, 'Template name is required'),
-    category: z.string()
-        .optional()
-        .describe('Template category (e.g., proposal, brief, sow, meeting-notes)'),
-    description: z.string().optional().describe('Template description'),
-    template_content: z.string().optional().describe('Template content (markdown)'),
-    variables: z.array(z.string())
-        .optional()
-        .describe('Template variables (e.g., {{project_name}})'),
-});
-/**
- * Process entity - workflows and methodologies
+ * Process — workflows, SOPs, and methodologies
  */
 export const ProcessSchema = EntityBaseSchema.extend({
     entity_type: z.literal('process'),
@@ -402,146 +302,91 @@ export const ProcessSchema = EntityBaseSchema.extend({
     description: z.string().optional().describe('Process description'),
     steps: z.string().optional().describe('Process steps (markdown)'),
     related_areas: z.array(z.string()).optional().describe('Related practice areas'),
-    related_templates: z.array(z.string()).optional().describe('Related template wikilinks'),
     owner: z.string().optional().describe('Person or team responsible (wikilink)'),
-    review_cycle: z.enum(['monthly', 'quarterly', 'annual', 'as-needed']).optional().describe('How often this process is reviewed'),
+    review_cycle: z.enum(['monthly', 'quarterly', 'annual', 'as-needed']).optional().describe('Review frequency'),
 });
 /**
- * Standard entity - guidelines and best practices
+ * Standard — guidelines and best practices
  */
 export const StandardSchema = EntityBaseSchema.extend({
     entity_type: z.literal('standard'),
     name: z.string().min(1, 'Standard name is required'),
-    category: z.string()
-        .optional()
-        .describe('Standard category (e.g., accessibility, design-principles, code-standards)'),
+    category: z.string().optional().describe('Category (e.g., accessibility, design-principles, code-standards)'),
     description: z.string().optional().describe('Standard description'),
     guidelines: z.string().optional().describe('Guidelines (markdown)'),
     examples: z.array(z.string()).optional().describe('Example wikilinks'),
 });
 /**
- * Reference entity - external references and inspirations
- */
-export const ReferenceSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('reference'),
-    name: z.string().min(1, 'Reference name is required'),
-    type: z.enum(['article', 'video', 'visualization', 'website', 'research', 'podcast', 'project', 'tool'])
-        .optional()
-        .describe('Reference type'),
-    date: z.string().optional().describe('Publication or creation date'),
-    source: z.string().optional().describe('Source/author'),
-    link: z.string().optional().describe('URL'),
-    related_projects: z.array(z.string()).optional().describe('Related project wikilinks'),
-    related_people: z.array(z.string()).optional().describe('Related people wikilinks'),
-    related_areas: z.array(z.string()).optional().describe('Related practice areas'),
-    description: z.string().optional().describe('Reference description'),
-});
-/**
- * Technique entity - methods and patterns
- */
-export const TechniqueSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('technique'),
-    name: z.string().min(1, 'Technique name is required'),
-    category: z.string()
-        .optional()
-        .describe('Technique category (e.g., visualization, interaction-pattern, data-structure)'),
-    description: z.string().optional().describe('Technique description'),
-    difficulty: z.enum(['beginner', 'intermediate', 'advanced'])
-        .optional()
-        .describe('Difficulty level'),
-    related_frameworks: z.array(z.string()).optional().describe('Related framework wikilinks'),
-    examples: z.array(z.string()).optional().describe('Example wikilinks'),
-});
-/**
- * Practice Area entity - firm capabilities and disciplines
- */
-export const PracticeAreaSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('practice-area'),
-    name: z.string().min(1, 'Practice area name is required'),
-    description: z.string().optional().describe('Overview of the discipline'),
-    capabilities: z.array(z.string()).optional().describe('Specific service offerings'),
-    related_case_studies: z.array(z.string()).optional().describe('Case study wikilinks'),
-    related_projects: z.array(z.string()).optional().describe('Related project wikilinks'),
-});
-/**
- * Case Study entity - portfolio narratives for completed projects
- *
- * Body markdown holds: Objective, Solution, Outcome, Team, Press, Awards.
+ * Case Study — portfolio narratives for completed projects
  */
 export const CaseStudySchema = EntityBaseSchema.extend({
     entity_type: z.literal('case-study'),
     title: z.string().min(1, 'Case study title is required'),
-    client: z.string().optional().describe('Client wikilink'),
+    client: z.string().optional().describe('Client organization wikilink'),
     year: z.number().optional().describe('Year of the project'),
     practice_areas: z.array(z.string()).optional().describe('Practice area wikilinks'),
     sectors: z.array(z.string()).optional().describe('Industry tags'),
     website_url: z.string().url().optional().describe('Project website URL'),
-    description: z.string().optional().describe('Short description / meta'),
+    description: z.string().optional().describe('Short description'),
 });
+// ══════════════════════════════════════════════════════════════════════════════
+// ══════════════════════════════════════════════════════════════════════════════
+// SCHEMA REGISTRY
+// ══════════════════════════════════════════════════════════════════════════════
 /**
- * Dataset entity - structured tabular data with CSV body
- */
-export const ColumnDefinitionSchema = z.object({
-    name: z.string().min(1),
-    type: z.enum(['string', 'number', 'boolean', 'date']),
-    required: z.boolean().optional(),
-    description: z.string().optional(),
-});
-export const DatasetSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('dataset'),
-    name: z.string().min(1, 'Dataset name is required'),
-    schema: z.array(ColumnDefinitionSchema).min(1, 'At least one column required'),
-});
-// ── App entity types ────────────────────────────────────────────────────────
-/**
- * Deck — presentation deck managed by the Schema Slides app plugin.
- * The document body is the full slide markdown (HTML comment directives + slide content).
- */
-export const DeckSchema = EntityBaseSchema.extend({
-    entity_type: z.literal('deck'),
-    title: z.string().min(1, 'Deck title is required'),
-    client: z.string().optional(),
-    date: z.string().min(1, 'Date is required'),
-    phase: z.string().optional(),
-    theme: z.enum(['dark', 'light']).default('dark'),
-    status: z.enum(['draft', 'review', 'approved']).default('draft'),
-    related_project: z.string().optional(),
-    related_client: z.string().optional(),
-});
-/**
- * Schema registry - maps entity types to their schemas
+ * Maps entity types to their Zod schemas.
+ * 17 built-in types. App plugins register additional types at runtime via SchemaRegistry.
  */
 export const ENTITY_SCHEMAS = {
-    // Project repos
+    // Identity (4)
+    person: PersonSchema,
+    organization: OrganizationSchema,
+    role: RoleSchema,
+    'practice-area': PracticeAreaSchema,
+    // Universal (10)
     project: ProjectSchema,
     meeting: MeetingSchema,
     decision: DecisionSchema,
     task: TaskSchema,
-    brief: BriefSchema,
-    artifact: ArtifactSchema,
+    document: DocumentSchema,
+    dataset: DatasetSchema,
+    reference: ReferenceSchema,
+    note: NoteSchema,
     deliverable: DeliverableSchema,
-    // Function repos
-    proposal: ProposalSchema,
-    contract: ContractSchema,
-    person: PersonSchema,
-    client: ClientSchema,
-    'financial-plan': FinancialPlanSchema,
+    publication: PublicationSchema,
     deal: DealSchema,
-    vendor: VendorSchema,
-    role: RoleSchema,
-    // Shared resource repos
-    template: TemplateSchema,
+    // Knowledge (3)
     process: ProcessSchema,
     standard: StandardSchema,
-    reference: ReferenceSchema,
-    technique: TechniqueSchema,
-    'practice-area': PracticeAreaSchema,
     'case-study': CaseStudySchema,
-    // Dataset
-    dataset: DatasetSchema,
-    // App entity types (registered by app plugins)
-    deck: DeckSchema,
 };
+/**
+ * Plural subfolder name → singular entity_type mapping
+ */
+export const PLURAL_TO_SINGULAR = {
+    'people': 'person',
+    'organizations': 'organization',
+    'roles': 'role',
+    'practice-areas': 'practice-area',
+    'projects': 'project',
+    'meetings': 'meeting',
+    'decisions': 'decision',
+    'tasks': 'task',
+    'documents': 'document',
+    'datasets': 'dataset',
+    'references': 'reference',
+    'notes': 'note',
+    'deliverables': 'deliverable',
+    'publications': 'publication',
+    'deals': 'deal',
+    'processes': 'process',
+    'standards': 'standard',
+    'case-studies': 'case-study',
+};
+/**
+ * Singular entity_type → plural subfolder name mapping
+ */
+export const SINGULAR_TO_PLURAL = Object.fromEntries(Object.entries(PLURAL_TO_SINGULAR).map(([plural, singular]) => [singular, plural]));
 /**
  * Validation helper with helpful error messages
  */
@@ -583,7 +428,7 @@ export function validateCustomEntity(data) {
     }
 }
 /**
- * Check if entity type is a known type
+ * Check if a type is a known built-in entity type
  */
 export function isKnownEntityType(type) {
     return type in ENTITY_SCHEMAS;