@elevasis/core 0.6.0 → 0.7.1

package/src/_gen/__tests__/scaffold-contracts.test.ts

@@ -0,0 +1,53 @@
+/**
+ * Snapshot test for the scaffold-contracts generator wrapper.
+ *
+ * Calls generate() (which runs the real script) and asserts:
+ * 1. The output file exists and has content.
+ * 2. The content matches the stored snapshot (drift detection).
+ *
+ * If the snapshot is missing it is created on first run. Subsequent runs fail
+ * if the output changes without an intentional snapshot update.
+ */
+
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { describe, it, expect } from 'vitest'
+
+/** Monorepo root relative to packages/core/src/_gen/__tests__/ */
+const ROOT = resolve(import.meta.dirname, '..', '..', '..', '..', '..')
+
+const OUTPUT_PATH = resolve(ROOT, 'packages/core/src/reference/_generated/contracts.md')
+
+describe('scaffold-contracts generator', () => {
+  it('output file exists and has content', () => {
+    // The generator must have been run (either manually or by CI gen step).
+    // This test validates the committed artifact — it does NOT re-run the generator
+    // so the test suite stays fast and deterministic.
+    let content: string
+    try {
+      content = readFileSync(OUTPUT_PATH, 'utf8')
+    } catch {
+      throw new Error(
+        `Generated file not found: ${OUTPUT_PATH}\n` +
+          `Run "pnpm scaffold:generate" or "node scripts/monorepo/generate-scaffold-contracts.js" first.`
+      )
+    }
+
+    expect(content.length).toBeGreaterThan(0)
+  })
+
+  it('output file matches stored snapshot', async () => {
+    let content: string
+    try {
+      content = readFileSync(OUTPUT_PATH, 'utf8')
+    } catch {
+      throw new Error(
+        `Generated file not found: ${OUTPUT_PATH}\n` +
+          `Run "pnpm scaffold:generate" first to produce the artifact before snapshotting.`
+      )
+    }
+
+    // Snapshot stored alongside test file in __snapshots__/
+    await expect(content).toMatchFileSnapshot(resolve(import.meta.dirname, '__snapshots__', 'contracts.md.snap'))
+  })
+})

package/src/_gen/scaffold-contracts.ts

@@ -0,0 +1,45 @@
+/**
+ * Thin _gen/ wrapper for the scaffold-contracts generator.
+ *
+ * The actual generation logic lives in scripts/monorepo/generate-scaffold-contracts.js.
+ * This wrapper provides the canonical generate() entry point so the generator
+ * participates in the @repo/gen-utils pattern (snapshot tests, drift detection,
+ * Turbo gen task).
+ *
+ * DO NOT move logic here — edit the script instead, then re-run generate().
+ */
+
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { resolve, dirname } from 'node:path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+/** Monorepo root — four levels up from packages/core/src/_gen/ */
+const ROOT = resolve(__dirname, '..', '..', '..', '..')
+
+/**
+ * Run the scaffold-contracts generator.
+ * Delegates to scripts/monorepo/generate-scaffold-contracts.js via child process
+ * so the existing script is the single source of implementation.
+ */
+export function generate(): void {
+  const result = spawnSync('node', ['scripts/monorepo/generate-scaffold-contracts.js'], {
+    stdio: 'inherit',
+    cwd: ROOT
+  })
+
+  if (result.error) {
+    throw new Error(`scaffold-contracts generator failed to spawn: ${result.error.message}`)
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`scaffold-contracts generator exited with status ${result.status}`)
+  }
+}
+
+// Allow direct invocation: node packages/core/src/_gen/scaffold-contracts.ts
+if (process.argv[1] && resolve(process.argv[1]) === __filename) {
+  generate()
+}

package/src/business/projects/index.ts

@@ -1 +1,2 @@
 export * from './types'
+export * from './sse-events'

package/src/business/projects/sse-events.ts

@@ -0,0 +1,21 @@
+export type DeliveryEntityType = 'project' | 'milestone' | 'task' | 'note' | 'activity'
+
+export type DeliveryEntityChangedAction = 'created' | 'updated' | 'deleted'
+
+export interface DeliveryConnectedEvent {
+  type: 'connected'
+  timestamp: number
+}
+
+export interface DeliveryEntityChangedEvent {
+  type: 'entity_changed'
+  timestamp: number
+  data: {
+    entityType: DeliveryEntityType
+    action: DeliveryEntityChangedAction
+    projectId: string
+    entityId: string
+  }
+}
+
+export type DeliverySSEEvent = DeliveryConnectedEvent | DeliveryEntityChangedEvent

package/src/execution/engine/tools/registry.ts

@@ -174,6 +174,7 @@ type TaskUpdate = Database['public']['Tables']['prj_tasks']['Update']
 type NoteInsert = Database['public']['Tables']['prj_notes']['Insert']
 type NoteUpdate = Database['public']['Tables']['prj_notes']['Update']
 type TaskResumeContextRow = Pick<TaskRow, 'id' | 'resume_context' | 'updated_at'>
+type DeleteEntityResult = { id: string; project_id: string }
 
 export interface IProjectsService {
   listProjects(
@@ -203,7 +204,7 @@ export interface IProjectsService {
     organizationId: string,
     input: Omit<MilestoneUpdate, 'organization_id'>
   ): Promise<MilestoneRow | null>
-  deleteMilestone(id: string, organizationId: string): Promise<boolean>
+  deleteMilestone(id: string, organizationId: string): Promise<DeleteEntityResult | null>
   listTasks(
     projectId: string,
     organizationId: string,
@@ -216,7 +217,7 @@ export interface IProjectsService {
   getTask(id: string, organizationId: string): Promise<TaskRow | null>
   createTask(input: Omit<TaskInsert, 'organization_id'> & { organizationId: string }): Promise<TaskRow>
   updateTask(id: string, organizationId: string, input: Omit<TaskUpdate, 'organization_id'>): Promise<TaskRow | null>
-  deleteTask(id: string, organizationId: string): Promise<boolean>
+  deleteTask(id: string, organizationId: string): Promise<DeleteEntityResult | null>
   mergeTaskResumeContext(
     id: string,
     organizationId: string,
@@ -225,7 +226,7 @@ export interface IProjectsService {
   listNotes(projectId: string, organizationId: string): Promise<NoteRow[]>
   createNote(input: Omit<NoteInsert, 'organization_id'> & { organizationId: string }): Promise<NoteRow>
   updateNote(id: string, organizationId: string, input: Omit<NoteUpdate, 'organization_id'>): Promise<NoteRow | null>
-  deleteNote(id: string, organizationId: string): Promise<boolean>
+  deleteNote(id: string, organizationId: string): Promise<DeleteEntityResult | null>
 }
 
 // =============================================================================

package/src/index.ts

@@ -52,3 +52,13 @@ export * from './integrations/oauth/index'
 
 // Credential types and utilities
 export * from './integrations/credentials/index'
+
+// Scaffold registry — browser-safe schema types and Zod schemas only.
+// For server-side loader functions, use: import { ... } from '@repo/core/scaffold-registry'
+export { ScaffoldRegistrySchema, ScaffoldEntryKindSchema } from './scaffold-registry/schema'
+export type {
+  ScaffoldRegistry,
+  ScaffoldRegistryEntry,
+  ScaffoldRef,
+  ScaffoldEntryKind
+} from './scaffold-registry/schema'

package/src/organization-model/__tests__/domains/identity.test.ts

@@ -257,6 +257,7 @@ describe('resolveOrganizationModel — identity domain integration', () => {
         industryCategory: 'Software / SaaS',
         geographicFocus: 'Global',
         timeZone: 'America/Chicago',
+        clientBrief: '',
         businessHours: {
           monday: { open: '09:00', close: '17:00' }
         }

package/src/organization-model/domains/identity.ts

@@ -67,7 +67,13 @@ export const IdentityDomainSchema = z.object({
    */
   timeZone: z.string().trim().max(100).default('UTC'),
   /** Typical operating hours per day of week. Empty object means not configured. */
-  businessHours: BusinessHoursSchema
+  businessHours: BusinessHoursSchema,
+  /**
+   * Long-form markdown capturing client context, problem narrative, and domain
+   * background. Populated by /setup; surfaced to agents as organizational context.
+   * Optional — many projects have no external client.
+   */
+  clientBrief: z.string().trim().default('')
 })
 
 // ---------------------------------------------------------------------------
@@ -83,5 +89,6 @@ export const DEFAULT_ORGANIZATION_MODEL_IDENTITY: z.infer<typeof IdentityDomainS
   industryCategory: '',
   geographicFocus: '',
   timeZone: 'UTC',
-  businessHours: {}
+  businessHours: {},
+  clientBrief: ''
 }

package/src/platform/constants/versions.ts

@@ -1,3 +1,3 @@
 export const VERSION = {
-  CURRENT: '1.6.3'
+  CURRENT: '1.6.5'
 }

package/src/platform/sse/events.ts

@@ -7,6 +7,7 @@
 import type { NotificationSSEEvent, NotificationCountUpdatedEvent } from '../../operations/notifications/sse-events'
 import type { ActivitySSEEvent, ActivityCreatedEvent, ActivityConnectedEvent } from '../../operations/activities/sse-events'
 import type { CommandQueueSSEEvent, CommandQueueTaskUpdatedEvent, CommandQueueConnectedEvent } from '../../commands/queue/sse-events'
+import type { DeliverySSEEvent, DeliveryConnectedEvent, DeliveryEntityChangedEvent } from '../../business/projects/sse-events'
 import type {
   ExecutionSSEEvent,
   ExecutionStartedEvent,
@@ -19,6 +20,7 @@ import type {
 export type { NotificationSSEEvent, NotificationCountUpdatedEvent }
 export type { ActivitySSEEvent, ActivityCreatedEvent, ActivityConnectedEvent }
 export type { CommandQueueSSEEvent, CommandQueueTaskUpdatedEvent, CommandQueueConnectedEvent }
+export type { DeliverySSEEvent, DeliveryConnectedEvent, DeliveryEntityChangedEvent }
 export type { ExecutionSSEEvent, ExecutionStartedEvent, ExecutionLogEvent, ExecutionCompleteEvent, ExecutionConnectedEvent }
 
 /**
@@ -31,4 +33,5 @@ export type AppSSEEvent =
   | NotificationSSEEvent
   | ActivitySSEEvent
   | CommandQueueSSEEvent
+  | DeliverySSEEvent
   | ExecutionSSEEvent

package/src/reference/_generated/contracts.md

@@ -1,4 +1,4 @@
-<!-- Auto-generated on 2026-04-20T23:27:16.482Z by scripts/monorepo/generate-scaffold-contracts.js -->
+<!-- Auto-generated on 2026-04-21 by scripts/monorepo/generate-scaffold-contracts.js -->
 ---
 title: Reference Contracts
 description: Auto-generated TypeScript contracts for SDK consumers. Do not edit manually.
@@ -363,6 +363,8 @@ export interface ElevasisFeaturesProviderProps {
   timeRange?: TimeRange
   operationsApiUrl?: string
   operationsSSEManager?: SSEConnectionManagerLike
+  deliveryApiUrl?: string
+  deliverySSEManager?: SSEConnectionManagerLike
   disabledSubsectionPaths?: string[]
   children: ReactNode
 }
@@ -381,6 +383,8 @@ export interface ElevasisFeaturesContextValue {
   timeRange?: TimeRange
   operationsApiUrl?: string
   operationsSSEManager?: SSEConnectionManagerLike
+  deliveryApiUrl?: string
+  deliverySSEManager?: SSEConnectionManagerLike
   disabledSubsectionPaths: string[]
   isFeatureEnabled: (key: string) => boolean
   getResolvedFeature: (key: string) => ResolvedFeatureModule | undefined

package/src/scaffold-registry/__tests__/schema.test.ts

@@ -0,0 +1,280 @@
+import { describe, expect, it } from 'vitest'
+import { ScaffoldEntryKindSchema, ScaffoldRegistryEntrySchema, ScaffoldRegistrySchema } from '../schema'
+
+// ---------------------------------------------------------------------------
+// Kind enum
+// ---------------------------------------------------------------------------
+
+describe('ScaffoldEntryKindSchema', () => {
+  it('accepts all declared kinds', () => {
+    const validKinds = [
+      'autogen',
+      'manual-scaffold',
+      'typed-id',
+      'sync-preservation',
+      'vibe-gated',
+      'sdk-cli-generator',
+      'validator',
+      'other'
+    ]
+    for (const kind of validKinds) {
+      expect(ScaffoldEntryKindSchema.safeParse(kind).success).toBe(true)
+    }
+  })
+
+  it('rejects unknown kinds', () => {
+    const result = ScaffoldEntryKindSchema.safeParse('unknown-kind')
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string', () => {
+    expect(ScaffoldEntryKindSchema.safeParse('').success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Valid full entry
+// ---------------------------------------------------------------------------
+
+const validEntry = {
+  id: 'business-directory-rename',
+  kind: 'manual-scaffold',
+  owner: 'packages/core',
+  sources: ['packages/core/src/business/**'],
+  dependents: [
+    {
+      path: '.navigation/_generated/skeleton.md',
+      regen: 'pnpm navigation:generate',
+      kind: 'autogen',
+      hint: 'Regenerate after rename.'
+    }
+  ]
+}
+
+describe('ScaffoldRegistryEntrySchema — valid entry', () => {
+  it('parses a complete valid entry', () => {
+    const result = ScaffoldRegistryEntrySchema.safeParse(validEntry)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('business-directory-rename')
+      expect(result.data.kind).toBe('manual-scaffold')
+      expect(result.data.sources).toHaveLength(1)
+      expect(result.data.dependents).toHaveLength(1)
+    }
+  })
+
+  it('accepts optional notes and cooldown_ms', () => {
+    const withOptionals = {
+      ...validEntry,
+      notes: 'Extra context here.',
+      cooldown_ms: 60_000
+    }
+    const result = ScaffoldRegistryEntrySchema.safeParse(withOptionals)
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts optional regen command when provided', () => {
+    const withRegen = { ...validEntry, regen: 'pnpm navigation:generate' }
+    const result = ScaffoldRegistryEntrySchema.safeParse(withRegen)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.regen).toBe('pnpm navigation:generate')
+    }
+  })
+
+  it('accepts entry without regen field (optional)', () => {
+    const result = ScaffoldRegistryEntrySchema.safeParse(validEntry)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.regen).toBeUndefined()
+    }
+  })
+
+  it('rejects regen as empty string', () => {
+    const withEmptyRegen = { ...validEntry, regen: '' }
+    const result = ScaffoldRegistryEntrySchema.safeParse(withEmptyRegen)
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects regen as non-string (number)', () => {
+    const withBadRegen = { ...validEntry, regen: 42 }
+    const result = ScaffoldRegistryEntrySchema.safeParse(withBadRegen)
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts entry without optional hint / regen in dependent', () => {
+    const minimalDependent = {
+      ...validEntry,
+      dependents: [{ path: 'some/path' }]
+    }
+    expect(ScaffoldRegistryEntrySchema.safeParse(minimalDependent).success).toBe(true)
+  })
+
+  it('accepts auto_regen: true', () => {
+    const withAutoRegen = { ...validEntry, auto_regen: true }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withAutoRegen).success).toBe(true)
+  })
+
+  it('accepts auto_regen: false', () => {
+    const withAutoRegen = { ...validEntry, auto_regen: false }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withAutoRegen).success).toBe(true)
+  })
+
+  it('accepts entry without auto_regen (optional)', () => {
+    expect(ScaffoldRegistryEntrySchema.safeParse(validEntry).success).toBe(true)
+  })
+
+  it('rejects auto_regen as a non-boolean', () => {
+    const withBadAutoRegen = { ...validEntry, auto_regen: 'yes' }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withBadAutoRegen).success).toBe(false)
+  })
+
+  it('parses all six seed-entry kinds', () => {
+    const kinds = ['autogen', 'manual-scaffold', 'typed-id', 'sync-preservation', 'vibe-gated', 'validator']
+    for (const kind of kinds) {
+      const result = ScaffoldRegistryEntrySchema.safeParse({ ...validEntry, kind })
+      expect(result.success, `kind ${kind} should parse`).toBe(true)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Invalid entries — required fields missing
+// ---------------------------------------------------------------------------
+
+describe('ScaffoldRegistryEntrySchema — invalid entries', () => {
+  it('rejects entry missing id', () => {
+    const { id: _id, ...withoutId } = validEntry
+    expect(ScaffoldRegistryEntrySchema.safeParse(withoutId).success).toBe(false)
+  })
+
+  it('rejects entry missing kind', () => {
+    const { kind: _kind, ...withoutKind } = validEntry
+    expect(ScaffoldRegistryEntrySchema.safeParse(withoutKind).success).toBe(false)
+  })
+
+  it('rejects entry missing owner', () => {
+    const { owner: _owner, ...withoutOwner } = validEntry
+    expect(ScaffoldRegistryEntrySchema.safeParse(withoutOwner).success).toBe(false)
+  })
+
+  it('rejects entry missing sources', () => {
+    const { sources: _sources, ...withoutSources } = validEntry
+    expect(ScaffoldRegistryEntrySchema.safeParse(withoutSources).success).toBe(false)
+  })
+
+  it('rejects entry missing dependents', () => {
+    const { dependents: _dependents, ...withoutDependents } = validEntry
+    expect(ScaffoldRegistryEntrySchema.safeParse(withoutDependents).success).toBe(false)
+  })
+
+  it('rejects invalid kind', () => {
+    const withBadKind = { ...validEntry, kind: 'not-a-real-kind' }
+    const result = ScaffoldRegistryEntrySchema.safeParse(withBadKind)
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects id with uppercase characters', () => {
+    const withBadId = { ...validEntry, id: 'BusinessDirectoryRename' }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withBadId).success).toBe(false)
+  })
+
+  it('rejects id with spaces', () => {
+    const withBadId = { ...validEntry, id: 'business directory rename' }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withBadId).success).toBe(false)
+  })
+
+  it('rejects empty sources array', () => {
+    const withEmptySources = { ...validEntry, sources: [] }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withEmptySources).success).toBe(false)
+  })
+
+  it('rejects empty dependents array', () => {
+    const withEmptyDependents = { ...validEntry, dependents: [] }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withEmptyDependents).success).toBe(false)
+  })
+
+  it('rejects dependent missing path', () => {
+    const withBadDependent = {
+      ...validEntry,
+      dependents: [{ regen: 'pnpm nav' }]
+    }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withBadDependent).success).toBe(false)
+  })
+
+  it('rejects negative cooldown_ms', () => {
+    const withBadCooldown = { ...validEntry, cooldown_ms: -1 }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withBadCooldown).success).toBe(false)
+  })
+
+  it('rejects non-integer cooldown_ms', () => {
+    const withBadCooldown = { ...validEntry, cooldown_ms: 300.5 }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withBadCooldown).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Top-level registry document
+// ---------------------------------------------------------------------------
+
+describe('ScaffoldRegistrySchema', () => {
+  const validRegistry = {
+    version: '1',
+    entries: [validEntry]
+  }
+
+  it('parses a valid registry document', () => {
+    const result = ScaffoldRegistrySchema.safeParse(validRegistry)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.version).toBe('1')
+      expect(result.data.entries).toHaveLength(1)
+    }
+  })
+
+  it('applies default version when omitted', () => {
+    const withoutVersion = { entries: [validEntry] }
+    const result = ScaffoldRegistrySchema.safeParse(withoutVersion)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.version).toBe('1')
+    }
+  })
+
+  it('rejects registry with no entries', () => {
+    const empty = { version: '1', entries: [] }
+    expect(ScaffoldRegistrySchema.safeParse(empty).success).toBe(false)
+  })
+
+  it('rejects registry missing entries key', () => {
+    expect(ScaffoldRegistrySchema.safeParse({ version: '1' }).success).toBe(false)
+  })
+
+  it('accepts multiple entries of different kinds', () => {
+    const multiEntry = {
+      version: '1',
+      entries: [
+        validEntry,
+        {
+          id: 'meta-json-updated',
+          kind: 'validator',
+          owner: 'apps/docs',
+          sources: ['apps/docs/content/docs/**/meta.json'],
+          dependents: [{ path: '(self)', regen: 'pnpm check-docs-meta' }]
+        },
+        {
+          id: 'external-template-hook-added',
+          kind: 'sync-preservation',
+          owner: 'external/_template',
+          sources: ['external/_template/.claude/hooks/*.mjs'],
+          dependents: [{ path: 'external/_template/.claude/settings.json', regen: 'manual' }]
+        }
+      ]
+    }
+    const result = ScaffoldRegistrySchema.safeParse(multiEntry)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.entries).toHaveLength(3)
+    }
+  })
+})