+ {{if .Data.Branding.LogoURL}}
+
+
+
+
+
+{{end}}
diff --git a/server/store/interfaces.go b/server/store/interfaces.go
index be94c62..9b9e9c7 100644
--- a/server/store/interfaces.go
+++ b/server/store/interfaces.go
@@ -48,6 +48,7 @@ type Stores struct {
RoutingPolicies RoutingPolicyStore
Sessions SessionStore
Surfaces SurfaceRegistryStore // v0.25.0: Surface lifecycle management
+ Workflows WorkflowStore // v0.26.1: Workflow definitions + stages
}
// =========================================
@@ -647,6 +648,11 @@ type SessionStore interface {
ListForChannel(ctx context.Context, channelID string) ([]models.SessionParticipant, error)
CountForChannel(ctx context.Context, channelID string) (int, error)
Delete(ctx context.Context, id string) error
+
+ // DeleteExpired removes sessions older than the given time that have
+ // no associated messages. Returns the number of deleted rows.
+ // Used by the background session cleanup job (v0.26.0).
+ DeleteExpired(ctx context.Context, olderThan time.Time) (int64, error)
}
// =========================================
diff --git a/server/store/postgres/sessions.go b/server/store/postgres/sessions.go
index 53cc961..96f5a1b 100644
--- a/server/store/postgres/sessions.go
+++ b/server/store/postgres/sessions.go
@@ -3,6 +3,7 @@ package postgres
import (
"context"
"database/sql"
+ "time"
"git.gobha.me/xcaliber/chat-switchboard/models"
)
@@ -87,6 +88,21 @@ func (s *SessionStore) Delete(ctx context.Context, id string) error {
return nil
}
+// DeleteExpired removes sessions created before olderThan whose channel
+// has no messages. Returns the count of deleted rows.
+func (s *SessionStore) DeleteExpired(ctx context.Context, olderThan time.Time) (int64, error) {
+ res, err := DB.ExecContext(ctx, `
+ DELETE FROM session_participants sp
+ WHERE sp.created_at < $1
+ AND NOT EXISTS (
+ SELECT 1 FROM messages m WHERE m.channel_id = sp.channel_id
+ )`, olderThan)
+ if err != nil {
+ return 0, err
+ }
+ return res.RowsAffected()
+}
+
// nullText returns nil for empty strings.
func nullText(s string) interface{} {
if s == "" {
diff --git a/server/store/postgres/stores.go b/server/store/postgres/stores.go
index 13247bc..f1714ea 100644
--- a/server/store/postgres/stores.go
+++ b/server/store/postgres/stores.go
@@ -41,5 +41,6 @@ func NewStores(db *sql.DB) store.Stores {
RoutingPolicies: NewRoutingPolicyStore(db),
Sessions: NewSessionStore(),
Surfaces: NewSurfaceRegistryStore(),
+ Workflows: NewWorkflowStore(),
}
}
diff --git a/server/store/postgres/workflows.go b/server/store/postgres/workflows.go
new file mode 100644
index 0000000..90654f4
--- /dev/null
+++ b/server/store/postgres/workflows.go
@@ -0,0 +1,316 @@
+package postgres
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+
+ "git.gobha.me/xcaliber/chat-switchboard/models"
+)
+
+// WorkflowStore implements store.WorkflowStore for Postgres.
+type WorkflowStore struct{}
+
+func NewWorkflowStore() *WorkflowStore { return &WorkflowStore{} }
+
+// ── Workflow CRUD ───────────────────────────
+
+func (s *WorkflowStore) Create(ctx context.Context, w *models.Workflow) error {
+ branding := jsonOrEmpty(w.Branding)
+ retention := jsonOrDefault(w.Retention, `{"mode":"archive"}`)
+ return DB.QueryRowContext(ctx, `
+ INSERT INTO workflows (team_id, name, slug, description, branding, entry_mode, is_active, on_complete, retention, created_by)
+ VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+ RETURNING id, version, created_at, updated_at`,
+ w.TeamID, w.Name, w.Slug, w.Description, branding, w.EntryMode,
+ w.IsActive, jsonOrNull(w.OnComplete), retention, w.CreatedBy,
+ ).Scan(&w.ID, &w.Version, &w.CreatedAt, &w.UpdatedAt)
+}
+
+func (s *WorkflowStore) GetByID(ctx context.Context, id string) (*models.Workflow, error) {
+ w := &models.Workflow{}
+ var branding, retention, onComplete []byte
+ err := DB.QueryRowContext(ctx, `
+ SELECT id, team_id, name, slug, description, branding, entry_mode, is_active,
+ version, on_complete, retention, created_by, created_at, updated_at
+ FROM workflows WHERE id = $1`, id,
+ ).Scan(&w.ID, &w.TeamID, &w.Name, &w.Slug, &w.Description, &branding,
+ &w.EntryMode, &w.IsActive, &w.Version, &onComplete, &retention,
+ &w.CreatedBy, &w.CreatedAt, &w.UpdatedAt)
+ if err != nil {
+ return nil, err
+ }
+ w.Branding = branding
+ w.OnComplete = onComplete
+ w.Retention = retention
+ return w, nil
+}
+
+func (s *WorkflowStore) GetBySlug(ctx context.Context, teamID *string, slug string) (*models.Workflow, error) {
+ var q string
+ var args []interface{}
+ if teamID != nil {
+ q = `SELECT id, team_id, name, slug, description, branding, entry_mode, is_active,
+ version, on_complete, retention, created_by, created_at, updated_at
+ FROM workflows WHERE team_id = $1 AND slug = $2`
+ args = []interface{}{*teamID, slug}
+ } else {
+ q = `SELECT id, team_id, name, slug, description, branding, entry_mode, is_active,
+ version, on_complete, retention, created_by, created_at, updated_at
+ FROM workflows WHERE team_id IS NULL AND slug = $1`
+ args = []interface{}{slug}
+ }
+ w := &models.Workflow{}
+ var branding, retention, onComplete []byte
+ err := DB.QueryRowContext(ctx, q, args...).Scan(
+ &w.ID, &w.TeamID, &w.Name, &w.Slug, &w.Description, &branding,
+ &w.EntryMode, &w.IsActive, &w.Version, &onComplete, &retention,
+ &w.CreatedBy, &w.CreatedAt, &w.UpdatedAt)
+ if err != nil {
+ return nil, err
+ }
+ w.Branding = branding
+ w.OnComplete = onComplete
+ w.Retention = retention
+ return w, nil
+}
+
+func (s *WorkflowStore) Update(ctx context.Context, id string, patch models.WorkflowPatch) error {
+ // Build dynamic SET clause
+ sets := []string{}
+ args := []interface{}{}
+ idx := 1
+
+ add := func(col string, val interface{}) {
+ sets = append(sets, fmt.Sprintf("%s = $%d", col, idx))
+ args = append(args, val)
+ idx++
+ }
+
+ if patch.Name != nil {
+ add("name", *patch.Name)
+ }
+ if patch.Description != nil {
+ add("description", *patch.Description)
+ }
+ if patch.Branding != nil {
+ add("branding", string(*patch.Branding))
+ }
+ if patch.EntryMode != nil {
+ add("entry_mode", *patch.EntryMode)
+ }
+ if patch.IsActive != nil {
+ add("is_active", *patch.IsActive)
+ }
+ if patch.OnComplete != nil {
+ add("on_complete", string(*patch.OnComplete))
+ }
+ if patch.Retention != nil {
+ add("retention", string(*patch.Retention))
+ }
+
+ if len(sets) == 0 {
+ return nil
+ }
+
+ // Increment version on any edit
+ sets = append(sets, fmt.Sprintf("version = version + 1"))
+
+ q := "UPDATE workflows SET "
+ for i, s := range sets {
+ if i > 0 {
+ q += ", "
+ }
+ q += s
+ }
+ q += fmt.Sprintf(" WHERE id = $%d", idx)
+ args = append(args, id)
+
+ _, err := DB.ExecContext(ctx, q, args...)
+ return err
+}
+
+func (s *WorkflowStore) Delete(ctx context.Context, id string) error {
+ _, err := DB.ExecContext(ctx, `DELETE FROM workflows WHERE id = $1`, id)
+ return err
+}
+
+func (s *WorkflowStore) ListForTeam(ctx context.Context, teamID string) ([]models.Workflow, error) {
+ return s.queryWorkflows(ctx, `
+ SELECT id, team_id, name, slug, description, branding, entry_mode, is_active,
+ version, on_complete, retention, created_by, created_at, updated_at
+ FROM workflows WHERE team_id = $1
+ ORDER BY name ASC`, teamID)
+}
+
+func (s *WorkflowStore) ListGlobal(ctx context.Context) ([]models.Workflow, error) {
+ return s.queryWorkflows(ctx, `
+ SELECT id, team_id, name, slug, description, branding, entry_mode, is_active,
+ version, on_complete, retention, created_by, created_at, updated_at
+ FROM workflows WHERE team_id IS NULL
+ ORDER BY name ASC`)
+}
+
+func (s *WorkflowStore) queryWorkflows(ctx context.Context, q string, args ...interface{}) ([]models.Workflow, error) {
+ rows, err := DB.QueryContext(ctx, q, args...)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ var result []models.Workflow
+ for rows.Next() {
+ var w models.Workflow
+ var branding, retention, onComplete []byte
+ if err := rows.Scan(&w.ID, &w.TeamID, &w.Name, &w.Slug, &w.Description,
+ &branding, &w.EntryMode, &w.IsActive, &w.Version, &onComplete,
+ &retention, &w.CreatedBy, &w.CreatedAt, &w.UpdatedAt); err != nil {
+ return nil, err
+ }
+ w.Branding = branding
+ w.OnComplete = onComplete
+ w.Retention = retention
+ result = append(result, w)
+ }
+ return result, rows.Err()
+}
+
+// ── Stages ──────────────────────────────────
+
+func (s *WorkflowStore) CreateStage(ctx context.Context, st *models.WorkflowStage) error {
+ formTpl := jsonOrEmpty(st.FormTemplate)
+ transRules := jsonOrEmpty(st.TransitionRules)
+ return DB.QueryRowContext(ctx, `
+ INSERT INTO workflow_stages (workflow_id, ordinal, name, persona_id, assignment_team_id,
+ form_template, history_mode, auto_transition, transition_rules)
+ VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+ RETURNING id, created_at`,
+ st.WorkflowID, st.Ordinal, st.Name, st.PersonaID, st.AssignmentTeamID,
+ formTpl, st.HistoryMode, st.AutoTransition, transRules,
+ ).Scan(&st.ID, &st.CreatedAt)
+}
+
+func (s *WorkflowStore) ListStages(ctx context.Context, workflowID string) ([]models.WorkflowStage, error) {
+ rows, err := DB.QueryContext(ctx, `
+ SELECT id, workflow_id, ordinal, name, persona_id, assignment_team_id,
+ form_template, history_mode, auto_transition, transition_rules, created_at
+ FROM workflow_stages WHERE workflow_id = $1
+ ORDER BY ordinal ASC`, workflowID)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ var result []models.WorkflowStage
+ for rows.Next() {
+ var st models.WorkflowStage
+ var formTpl, transRules []byte
+ if err := rows.Scan(&st.ID, &st.WorkflowID, &st.Ordinal, &st.Name,
+ &st.PersonaID, &st.AssignmentTeamID, &formTpl, &st.HistoryMode,
+ &st.AutoTransition, &transRules, &st.CreatedAt); err != nil {
+ return nil, err
+ }
+ st.FormTemplate = formTpl
+ st.TransitionRules = transRules
+ result = append(result, st)
+ }
+ return result, rows.Err()
+}
+
+func (s *WorkflowStore) UpdateStage(ctx context.Context, st *models.WorkflowStage) error {
+ formTpl := jsonOrEmpty(st.FormTemplate)
+ transRules := jsonOrEmpty(st.TransitionRules)
+ _, err := DB.ExecContext(ctx, `
+ UPDATE workflow_stages
+ SET ordinal = $2, name = $3, persona_id = $4, assignment_team_id = $5,
+ form_template = $6, history_mode = $7, auto_transition = $8, transition_rules = $9
+ WHERE id = $1`,
+ st.ID, st.Ordinal, st.Name, st.PersonaID, st.AssignmentTeamID,
+ formTpl, st.HistoryMode, st.AutoTransition, transRules)
+ return err
+}
+
+func (s *WorkflowStore) DeleteStage(ctx context.Context, id string) error {
+ _, err := DB.ExecContext(ctx, `DELETE FROM workflow_stages WHERE id = $1`, id)
+ return err
+}
+
+func (s *WorkflowStore) ReorderStages(ctx context.Context, workflowID string, orderedIDs []string) error {
+ tx, err := DB.BeginTx(ctx, nil)
+ if err != nil {
+ return err
+ }
+ defer tx.Rollback()
+
+ for i, id := range orderedIDs {
+ if _, err := tx.ExecContext(ctx, `
+ UPDATE workflow_stages SET ordinal = $1 WHERE id = $2 AND workflow_id = $3`,
+ i, id, workflowID); err != nil {
+ return err
+ }
+ }
+ return tx.Commit()
+}
+
+// ── Versions ────────────────────────────────
+
+func (s *WorkflowStore) Publish(ctx context.Context, v *models.WorkflowVersion) error {
+ return DB.QueryRowContext(ctx, `
+ INSERT INTO workflow_versions (workflow_id, version_number, snapshot)
+ VALUES ($1, $2, $3)
+ RETURNING id, created_at`,
+ v.WorkflowID, v.VersionNumber, string(v.Snapshot),
+ ).Scan(&v.ID, &v.CreatedAt)
+}
+
+func (s *WorkflowStore) GetVersion(ctx context.Context, workflowID string, versionNumber int) (*models.WorkflowVersion, error) {
+ v := &models.WorkflowVersion{}
+ var snapshot []byte
+ err := DB.QueryRowContext(ctx, `
+ SELECT id, workflow_id, version_number, snapshot, created_at
+ FROM workflow_versions WHERE workflow_id = $1 AND version_number = $2`,
+ workflowID, versionNumber,
+ ).Scan(&v.ID, &v.WorkflowID, &v.VersionNumber, &snapshot, &v.CreatedAt)
+ if err != nil {
+ return nil, err
+ }
+ v.Snapshot = snapshot
+ return v, nil
+}
+
+func (s *WorkflowStore) GetLatestVersion(ctx context.Context, workflowID string) (*models.WorkflowVersion, error) {
+ v := &models.WorkflowVersion{}
+ var snapshot []byte
+ err := DB.QueryRowContext(ctx, `
+ SELECT id, workflow_id, version_number, snapshot, created_at
+ FROM workflow_versions WHERE workflow_id = $1
+ ORDER BY version_number DESC LIMIT 1`,
+ workflowID,
+ ).Scan(&v.ID, &v.WorkflowID, &v.VersionNumber, &snapshot, &v.CreatedAt)
+ if err != nil {
+ return nil, err
+ }
+ v.Snapshot = snapshot
+ return v, nil
+}
+
+// ── Helpers ─────────────────────────────────
+
+func jsonOrEmpty(b json.RawMessage) string {
+ if len(b) == 0 {
+ return "{}"
+ }
+ return string(b)
+}
+
+func jsonOrDefault(b json.RawMessage, def string) string {
+ if len(b) == 0 {
+ return def
+ }
+ return string(b)
+}
+
+func jsonOrNull(b json.RawMessage) interface{} {
+ if len(b) == 0 || string(b) == "null" {
+ return nil
+ }
+ return string(b)
+}
diff --git a/server/store/sqlite/sessions.go b/server/store/sqlite/sessions.go
index 66e82c5..7d5976c 100644
--- a/server/store/sqlite/sessions.go
+++ b/server/store/sqlite/sessions.go
@@ -3,6 +3,7 @@ package sqlite
import (
"context"
"database/sql"
+ "time"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/store"
@@ -95,6 +96,21 @@ func (s *SessionStore) Delete(ctx context.Context, id string) error {
return nil
}
+// DeleteExpired removes sessions created before olderThan whose channel
+// has no messages. Returns the count of deleted rows.
+func (s *SessionStore) DeleteExpired(ctx context.Context, olderThan time.Time) (int64, error) {
+ res, err := DB.ExecContext(ctx, `
+ DELETE FROM session_participants
+ WHERE created_at < ?
+ AND NOT EXISTS (
+ SELECT 1 FROM messages WHERE messages.channel_id = session_participants.channel_id
+ )`, olderThan)
+ if err != nil {
+ return 0, err
+ }
+ return res.RowsAffected()
+}
+
func nullText(s string) interface{} {
if s == "" {
return nil
diff --git a/server/store/sqlite/stores.go b/server/store/sqlite/stores.go
index 1f57f86..562875b 100644
--- a/server/store/sqlite/stores.go
+++ b/server/store/sqlite/stores.go
@@ -40,5 +40,6 @@ func NewStores(db *sql.DB) store.Stores {
CapOverrides: NewCapOverrideStore(),
RoutingPolicies: NewRoutingPolicyStore(),
Sessions: NewSessionStore(),
+ Workflows: NewWorkflowStore(),
}
}
diff --git a/server/store/sqlite/workflows.go b/server/store/sqlite/workflows.go
new file mode 100644
index 0000000..d652425
--- /dev/null
+++ b/server/store/sqlite/workflows.go
@@ -0,0 +1,328 @@
+package sqlite
+
+import (
+ "context"
+ "database/sql"
+ "encoding/json"
+ "time"
+
+ "git.gobha.me/xcaliber/chat-switchboard/models"
+ "git.gobha.me/xcaliber/chat-switchboard/store"
+)
+
+// WorkflowStore implements store.WorkflowStore for SQLite.
+type WorkflowStore struct{}
+
+func NewWorkflowStore() *WorkflowStore { return &WorkflowStore{} }
+
+// ── Workflow CRUD ───────────────────────────
+
+func (s *WorkflowStore) Create(ctx context.Context, w *models.Workflow) error {
+ w.ID = store.NewID()
+ now := time.Now().UTC()
+ w.CreatedAt = now
+ w.UpdatedAt = now
+ w.Version = 1
+ branding := jsonOrEmpty(w.Branding)
+ retention := jsonOrDefault(w.Retention, `{"mode":"archive"}`)
+ _, err := DB.ExecContext(ctx, `
+ INSERT INTO workflows (id, team_id, name, slug, description, branding, entry_mode,
+ is_active, version, on_complete, retention, created_by, created_at, updated_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+ w.ID, w.TeamID, w.Name, w.Slug, w.Description, branding, w.EntryMode,
+ boolToInt(w.IsActive), w.Version, jsonOrNull(w.OnComplete), retention,
+ w.CreatedBy, w.CreatedAt.Format(time.RFC3339), w.UpdatedAt.Format(time.RFC3339))
+ return err
+}
+
+func (s *WorkflowStore) GetByID(ctx context.Context, id string) (*models.Workflow, error) {
+ return s.scanOne(ctx, `
+ SELECT id, team_id, name, slug, description, branding, entry_mode, is_active,
+ version, on_complete, retention, created_by, created_at, updated_at
+ FROM workflows WHERE id = ?`, id)
+}
+
+func (s *WorkflowStore) GetBySlug(ctx context.Context, teamID *string, slug string) (*models.Workflow, error) {
+ if teamID != nil {
+ return s.scanOne(ctx, `
+ SELECT id, team_id, name, slug, description, branding, entry_mode, is_active,
+ version, on_complete, retention, created_by, created_at, updated_at
+ FROM workflows WHERE team_id = ? AND slug = ?`, *teamID, slug)
+ }
+ return s.scanOne(ctx, `
+ SELECT id, team_id, name, slug, description, branding, entry_mode, is_active,
+ version, on_complete, retention, created_by, created_at, updated_at
+ FROM workflows WHERE team_id IS NULL AND slug = ?`, slug)
+}
+
+func (s *WorkflowStore) Update(ctx context.Context, id string, patch models.WorkflowPatch) error {
+ sets := []string{}
+ args := []interface{}{}
+
+ if patch.Name != nil {
+ sets = append(sets, "name = ?")
+ args = append(args, *patch.Name)
+ }
+ if patch.Description != nil {
+ sets = append(sets, "description = ?")
+ args = append(args, *patch.Description)
+ }
+ if patch.Branding != nil {
+ sets = append(sets, "branding = ?")
+ args = append(args, string(*patch.Branding))
+ }
+ if patch.EntryMode != nil {
+ sets = append(sets, "entry_mode = ?")
+ args = append(args, *patch.EntryMode)
+ }
+ if patch.IsActive != nil {
+ sets = append(sets, "is_active = ?")
+ args = append(args, boolToInt(*patch.IsActive))
+ }
+ if patch.OnComplete != nil {
+ sets = append(sets, "on_complete = ?")
+ args = append(args, string(*patch.OnComplete))
+ }
+ if patch.Retention != nil {
+ sets = append(sets, "retention = ?")
+ args = append(args, string(*patch.Retention))
+ }
+
+ if len(sets) == 0 {
+ return nil
+ }
+
+ sets = append(sets, "version = version + 1")
+ sets = append(sets, "updated_at = ?")
+ args = append(args, time.Now().UTC().Format(time.RFC3339))
+
+ q := "UPDATE workflows SET "
+ for i, s := range sets {
+ if i > 0 {
+ q += ", "
+ }
+ q += s
+ }
+ q += " WHERE id = ?"
+ args = append(args, id)
+
+ _, err := DB.ExecContext(ctx, q, args...)
+ return err
+}
+
+func (s *WorkflowStore) Delete(ctx context.Context, id string) error {
+ _, err := DB.ExecContext(ctx, `DELETE FROM workflows WHERE id = ?`, id)
+ return err
+}
+
+func (s *WorkflowStore) ListForTeam(ctx context.Context, teamID string) ([]models.Workflow, error) {
+ return s.queryWorkflows(ctx, `
+ SELECT id, team_id, name, slug, description, branding, entry_mode, is_active,
+ version, on_complete, retention, created_by, created_at, updated_at
+ FROM workflows WHERE team_id = ?
+ ORDER BY name ASC`, teamID)
+}
+
+func (s *WorkflowStore) ListGlobal(ctx context.Context) ([]models.Workflow, error) {
+ return s.queryWorkflows(ctx, `
+ SELECT id, team_id, name, slug, description, branding, entry_mode, is_active,
+ version, on_complete, retention, created_by, created_at, updated_at
+ FROM workflows WHERE team_id IS NULL
+ ORDER BY name ASC`)
+}
+
+// ── Stages ──────────────────────────────────
+
+func (s *WorkflowStore) CreateStage(ctx context.Context, st *models.WorkflowStage) error {
+ st.ID = store.NewID()
+ st.CreatedAt = time.Now().UTC()
+ formTpl := jsonOrEmpty(st.FormTemplate)
+ transRules := jsonOrEmpty(st.TransitionRules)
+ _, err := DB.ExecContext(ctx, `
+ INSERT INTO workflow_stages (id, workflow_id, ordinal, name, persona_id, assignment_team_id,
+ form_template, history_mode, auto_transition, transition_rules, created_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+ st.ID, st.WorkflowID, st.Ordinal, st.Name, st.PersonaID, st.AssignmentTeamID,
+ formTpl, st.HistoryMode, boolToInt(st.AutoTransition), transRules,
+ st.CreatedAt.Format(time.RFC3339))
+ return err
+}
+
+func (s *WorkflowStore) ListStages(ctx context.Context, workflowID string) ([]models.WorkflowStage, error) {
+ rows, err := DB.QueryContext(ctx, `
+ SELECT id, workflow_id, ordinal, name, persona_id, assignment_team_id,
+ form_template, history_mode, auto_transition, transition_rules, created_at
+ FROM workflow_stages WHERE workflow_id = ?
+ ORDER BY ordinal ASC`, workflowID)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ var result []models.WorkflowStage
+ for rows.Next() {
+ var st models.WorkflowStage
+ var formTpl, transRules string
+ var autoTrans int
+ if err := rows.Scan(&st.ID, &st.WorkflowID, &st.Ordinal, &st.Name,
+ &st.PersonaID, &st.AssignmentTeamID, &formTpl, &st.HistoryMode,
+ &autoTrans, &transRules, &st.CreatedAt); err != nil {
+ return nil, err
+ }
+ st.FormTemplate = json.RawMessage(formTpl)
+ st.TransitionRules = json.RawMessage(transRules)
+ st.AutoTransition = autoTrans != 0
+ result = append(result, st)
+ }
+ return result, rows.Err()
+}
+
+func (s *WorkflowStore) UpdateStage(ctx context.Context, st *models.WorkflowStage) error {
+ formTpl := jsonOrEmpty(st.FormTemplate)
+ transRules := jsonOrEmpty(st.TransitionRules)
+ _, err := DB.ExecContext(ctx, `
+ UPDATE workflow_stages
+ SET ordinal = ?, name = ?, persona_id = ?, assignment_team_id = ?,
+ form_template = ?, history_mode = ?, auto_transition = ?, transition_rules = ?
+ WHERE id = ?`,
+ st.Ordinal, st.Name, st.PersonaID, st.AssignmentTeamID,
+ formTpl, st.HistoryMode, boolToInt(st.AutoTransition), transRules, st.ID)
+ return err
+}
+
+func (s *WorkflowStore) DeleteStage(ctx context.Context, id string) error {
+ _, err := DB.ExecContext(ctx, `DELETE FROM workflow_stages WHERE id = ?`, id)
+ return err
+}
+
+func (s *WorkflowStore) ReorderStages(ctx context.Context, workflowID string, orderedIDs []string) error {
+ tx, err := DB.BeginTx(ctx, nil)
+ if err != nil {
+ return err
+ }
+ defer tx.Rollback()
+
+ for i, id := range orderedIDs {
+ if _, err := tx.ExecContext(ctx, `
+ UPDATE workflow_stages SET ordinal = ? WHERE id = ? AND workflow_id = ?`,
+ i, id, workflowID); err != nil {
+ return err
+ }
+ }
+ return tx.Commit()
+}
+
+// ── Versions ────────────────────────────────
+
+func (s *WorkflowStore) Publish(ctx context.Context, v *models.WorkflowVersion) error {
+ v.ID = store.NewID()
+ v.CreatedAt = time.Now().UTC()
+ _, err := DB.ExecContext(ctx, `
+ INSERT INTO workflow_versions (id, workflow_id, version_number, snapshot, created_at)
+ VALUES (?, ?, ?, ?, ?)`,
+ v.ID, v.WorkflowID, v.VersionNumber, string(v.Snapshot),
+ v.CreatedAt.Format(time.RFC3339))
+ return err
+}
+
+func (s *WorkflowStore) GetVersion(ctx context.Context, workflowID string, versionNumber int) (*models.WorkflowVersion, error) {
+ v := &models.WorkflowVersion{}
+ var snapshot string
+ err := DB.QueryRowContext(ctx, `
+ SELECT id, workflow_id, version_number, snapshot, created_at
+ FROM workflow_versions WHERE workflow_id = ? AND version_number = ?`,
+ workflowID, versionNumber,
+ ).Scan(&v.ID, &v.WorkflowID, &v.VersionNumber, &snapshot, &v.CreatedAt)
+ if err != nil {
+ return nil, err
+ }
+ v.Snapshot = json.RawMessage(snapshot)
+ return v, nil
+}
+
+func (s *WorkflowStore) GetLatestVersion(ctx context.Context, workflowID string) (*models.WorkflowVersion, error) {
+ v := &models.WorkflowVersion{}
+ var snapshot string
+ err := DB.QueryRowContext(ctx, `
+ SELECT id, workflow_id, version_number, snapshot, created_at
+ FROM workflow_versions WHERE workflow_id = ?
+ ORDER BY version_number DESC LIMIT 1`,
+ workflowID,
+ ).Scan(&v.ID, &v.WorkflowID, &v.VersionNumber, &snapshot, &v.CreatedAt)
+ if err != nil {
+ return nil, err
+ }
+ v.Snapshot = json.RawMessage(snapshot)
+ return v, nil
+}
+
+// ── Helpers ─────────────────────────────────
+
+func (s *WorkflowStore) scanOne(ctx context.Context, q string, args ...interface{}) (*models.Workflow, error) {
+ w := &models.Workflow{}
+ var branding, retention string
+ var onComplete sql.NullString
+ var isActive int
+ err := DB.QueryRowContext(ctx, q, args...).Scan(
+ &w.ID, &w.TeamID, &w.Name, &w.Slug, &w.Description, &branding,
+ &w.EntryMode, &isActive, &w.Version, &onComplete, &retention,
+ &w.CreatedBy, &w.CreatedAt, &w.UpdatedAt)
+ if err != nil {
+ return nil, err
+ }
+ w.Branding = json.RawMessage(branding)
+ w.Retention = json.RawMessage(retention)
+ w.IsActive = isActive != 0
+ if onComplete.Valid {
+ w.OnComplete = json.RawMessage(onComplete.String)
+ }
+ return w, nil
+}
+
+func (s *WorkflowStore) queryWorkflows(ctx context.Context, q string, args ...interface{}) ([]models.Workflow, error) {
+ rows, err := DB.QueryContext(ctx, q, args...)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ var result []models.Workflow
+ for rows.Next() {
+ var w models.Workflow
+ var branding, retention string
+ var onComplete sql.NullString
+ var isActive int
+ if err := rows.Scan(&w.ID, &w.TeamID, &w.Name, &w.Slug, &w.Description,
+ &branding, &w.EntryMode, &isActive, &w.Version, &onComplete,
+ &retention, &w.CreatedBy, &w.CreatedAt, &w.UpdatedAt); err != nil {
+ return nil, err
+ }
+ w.Branding = json.RawMessage(branding)
+ w.Retention = json.RawMessage(retention)
+ w.IsActive = isActive != 0
+ if onComplete.Valid {
+ w.OnComplete = json.RawMessage(onComplete.String)
+ }
+ result = append(result, w)
+ }
+ return result, rows.Err()
+}
+
+func jsonOrEmpty(b json.RawMessage) string {
+ if len(b) == 0 {
+ return "{}"
+ }
+ return string(b)
+}
+
+func jsonOrDefault(b json.RawMessage, def string) string {
+ if len(b) == 0 {
+ return def
+ }
+ return string(b)
+}
+
+func jsonOrNull(b json.RawMessage) interface{} {
+ if len(b) == 0 || string(b) == "null" {
+ return nil
+ }
+ return string(b)
+}
diff --git a/server/store/workflow_iface.go b/server/store/workflow_iface.go
new file mode 100644
index 0000000..9971a12
--- /dev/null
+++ b/server/store/workflow_iface.go
@@ -0,0 +1,31 @@
+package store
+
+import (
+ "context"
+
+ "git.gobha.me/xcaliber/chat-switchboard/models"
+)
+
+// WorkflowStore manages workflow definitions, stages, and version snapshots.
+type WorkflowStore interface {
+ // Workflow CRUD
+ Create(ctx context.Context, w *models.Workflow) error
+ GetByID(ctx context.Context, id string) (*models.Workflow, error)
+ GetBySlug(ctx context.Context, teamID *string, slug string) (*models.Workflow, error)
+ Update(ctx context.Context, id string, patch models.WorkflowPatch) error
+ Delete(ctx context.Context, id string) error
+ ListForTeam(ctx context.Context, teamID string) ([]models.Workflow, error)
+ ListGlobal(ctx context.Context) ([]models.Workflow, error)
+
+ // Stage CRUD
+ CreateStage(ctx context.Context, s *models.WorkflowStage) error
+ ListStages(ctx context.Context, workflowID string) ([]models.WorkflowStage, error)
+ UpdateStage(ctx context.Context, s *models.WorkflowStage) error
+ DeleteStage(ctx context.Context, id string) error
+ ReorderStages(ctx context.Context, workflowID string, orderedIDs []string) error
+
+ // Versioning
+ Publish(ctx context.Context, v *models.WorkflowVersion) error
+ GetVersion(ctx context.Context, workflowID string, versionNumber int) (*models.WorkflowVersion, error)
+ GetLatestVersion(ctx context.Context, workflowID string) (*models.WorkflowVersion, error)
+}
diff --git a/server/tools/registry.go b/server/tools/registry.go
index 34245ed..12ba19c 100644
--- a/server/tools/registry.go
+++ b/server/tools/registry.go
@@ -36,15 +36,6 @@ func AllDefinitions() []ToolDef {
return defs
}
-// AllDefinitionsFiltered returns tool definitions excluding any names in the
-// disabled set. Used when the frontend sends a disabled_tools list.
-//
-// Deprecated: use AvailableFor() for context-aware filtering. This wrapper
-// remains for call sites that don't yet have a ToolContext.
-func AllDefinitionsFiltered(disabled map[string]bool) []ToolDef {
- return AvailableFor(ToolContext{}, disabled)
-}
-
// AvailableFor returns tool definitions available in the given context,
// excluding any names in the disabled set. Tools that implement
// ContextualTool have their Availability() predicate evaluated against
diff --git a/server/tools/workflow.go b/server/tools/workflow.go
new file mode 100644
index 0000000..0bbef05
--- /dev/null
+++ b/server/tools/workflow.go
@@ -0,0 +1,243 @@
+package tools
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "log"
+ "time"
+
+ "git.gobha.me/xcaliber/chat-switchboard/database"
+ "git.gobha.me/xcaliber/chat-switchboard/models"
+ "git.gobha.me/xcaliber/chat-switchboard/store"
+)
+
+// ── Late Registration ────────────────────────
+
+// RegisterWorkflowTools registers the workflow_advance tool.
+// Called from main.go after stores are initialized.
+func RegisterWorkflowTools(stores store.Stores) {
+ if stores.Workflows == nil {
+ log.Println("⚠ workflow tools: WorkflowStore not available, skipping registration")
+ return
+ }
+ Register(&workflowAdvanceTool{stores: stores})
+ log.Println("✅ workflow tools registered (workflow_advance)")
+}
+
+// ═══════════════════════════════════════════
+// workflow_advance
+// ═══════════════════════════════════════════
+//
+// Called by the stage persona when it has collected all required form
+// data from the visitor. Triggers a stage transition — same effect as
+// the human-triggered POST /channels/:id/workflow/advance endpoint.
+
+type workflowAdvanceTool struct {
+ BaseTool
+ stores store.Stores
+}
+
+// Override availability: only available inside workflow channels.
+func (t *workflowAdvanceTool) Availability() Require { return RequireWorkflow }
+
+func (t *workflowAdvanceTool) Definition() ToolDef {
+ return ToolDef{
+ Name: "workflow_advance",
+ DisplayName: "Advance Workflow",
+ Category: "workflow",
+ Description: "Advance the workflow to the next stage. Call this when you have " +
+ "collected all required information from the visitor. Pass the collected " +
+ "data as a JSON object — it will be saved and made available to the next stage.",
+ Parameters: JSONSchema(map[string]interface{}{
+ "data": map[string]interface{}{
+ "type": "object",
+ "description": "Collected form data as key-value pairs. Must include all fields defined in the stage's form template.",
+ },
+ "summary": Prop("string", "Brief summary of what was collected (1-2 sentences, shown in stage notes)"),
+ }, []string{"data"}),
+ }
+}
+
+func (t *workflowAdvanceTool) Execute(ctx context.Context, execCtx ExecutionContext, argsJSON string) (string, error) {
+ var args struct {
+ Data json.RawMessage `json:"data"`
+ Summary string `json:"summary"`
+ }
+ if err := json.Unmarshal([]byte(argsJSON), &args); err != nil {
+ return "", fmt.Errorf("invalid arguments: %w", err)
+ }
+
+ if len(args.Data) == 0 || string(args.Data) == "null" {
+ return "", fmt.Errorf("data is required")
+ }
+
+ channelID := execCtx.ChannelID
+ if channelID == "" {
+ return "", fmt.Errorf("no channel context")
+ }
+
+ // Read current workflow state
+ var workflowID string
+ var currentStage int
+ var status string
+ var wfID *string
+ err := database.DB.QueryRowContext(ctx, database.Q(`
+ SELECT workflow_id, COALESCE(current_stage, 0), COALESCE(workflow_status, 'active')
+ FROM channels WHERE id = $1 AND type = 'workflow'
+ `), channelID).Scan(&wfID, ¤tStage, &status)
+ if err != nil || wfID == nil {
+ return "", fmt.Errorf("not a workflow channel")
+ }
+ workflowID = *wfID
+
+ if status != "active" {
+ return "", fmt.Errorf("workflow is %s, cannot advance", status)
+ }
+
+ // Load stages
+ stages, err := t.stores.Workflows.ListStages(ctx, workflowID)
+ if err != nil {
+ return "", fmt.Errorf("failed to load stages: %w", err)
+ }
+
+ // Merge collected data into stage_data
+ mergedData := MergeWorkflowStageData(ctx, channelID, args.Data)
+ nextStage := currentStage + 1
+
+ if nextStage >= len(stages) {
+ // Workflow complete
+ _, err = database.DB.ExecContext(ctx, database.Q(`
+ UPDATE channels
+ SET current_stage = $1, workflow_status = 'completed',
+ stage_data = $2, last_activity_at = $3, ai_mode = 'off'
+ WHERE id = $4
+ `), nextStage, mergedData, time.Now().UTC(), channelID)
+ if err != nil {
+ return "", fmt.Errorf("failed to complete workflow: %w", err)
+ }
+
+ // Create note with collected data
+ CreateWorkflowStageNote(ctx, t.stores, channelID, currentStage, args.Data, args.Summary)
+
+ result, _ := json.Marshal(map[string]interface{}{
+ "status": "completed",
+ "current_stage": nextStage,
+ "message": "Workflow completed successfully.",
+ })
+ return string(result), nil
+ }
+
+ // Advance to next stage
+ _, err = database.DB.ExecContext(ctx, database.Q(`
+ UPDATE channels
+ SET current_stage = $1, stage_data = $2, last_activity_at = $3
+ WHERE id = $4
+ `), nextStage, mergedData, time.Now().UTC(), channelID)
+ if err != nil {
+ return "", fmt.Errorf("failed to advance: %w", err)
+ }
+
+ // Create note with collected data
+ CreateWorkflowStageNote(ctx, t.stores, channelID, currentStage, args.Data, args.Summary)
+
+ // Create assignment if next stage has an assignment team
+ nextStageDef := stages[nextStage]
+ if nextStageDef.AssignmentTeamID != nil {
+ CreateWorkflowAssignment(ctx, channelID, nextStage, *nextStageDef.AssignmentTeamID)
+ }
+
+ result, _ := json.Marshal(map[string]interface{}{
+ "status": "active",
+ "current_stage": nextStage,
+ "stage_name": nextStageDef.Name,
+ "message": fmt.Sprintf("Advanced to stage %d: %s", nextStage, nextStageDef.Name),
+ })
+ return string(result), nil
+}
+
+// ── Shared helpers (used by both tool and handler) ─
+
+// MergeWorkflowStageData reads current stage_data, merges new data in Go, returns JSON string.
+func MergeWorkflowStageData(ctx context.Context, channelID string, newData json.RawMessage) string {
+ var existing []byte
+ _ = database.DB.QueryRowContext(ctx, database.Q(`
+ SELECT COALESCE(stage_data, '{}') FROM channels WHERE id = $1
+ `), channelID).Scan(&existing)
+
+ if len(newData) == 0 || string(newData) == "null" {
+ if len(existing) == 0 {
+ return "{}"
+ }
+ return string(existing)
+ }
+
+ var base map[string]interface{}
+ if err := json.Unmarshal(existing, &base); err != nil {
+ base = map[string]interface{}{}
+ }
+ var incoming map[string]interface{}
+ if err := json.Unmarshal(newData, &incoming); err == nil {
+ for k, v := range incoming {
+ base[k] = v
+ }
+ }
+ merged, _ := json.Marshal(base)
+ return string(merged)
+}
+
+// CreateWorkflowStageNote persists collected form data as a channel-scoped note.
+func CreateWorkflowStageNote(ctx context.Context, stores store.Stores, channelID string, stageOrdinal int, data json.RawMessage, summary string) {
+ if stores.Notes == nil || len(data) == 0 || string(data) == "null" {
+ return
+ }
+
+ title := fmt.Sprintf("Stage %d collected data", stageOrdinal)
+ if summary != "" {
+ title = fmt.Sprintf("Stage %d: %s", stageOrdinal, summary)
+ }
+
+ content := string(data)
+
+ // Find workflow channel owner for the note's user_id
+ var userID string
+ _ = database.DB.QueryRowContext(ctx, database.Q(`
+ SELECT user_id FROM channels WHERE id = $1
+ `), channelID).Scan(&userID)
+ if userID == "" {
+ return
+ }
+
+ note := &models.Note{
+ Title: title,
+ Content: content,
+ SourceChannelID: &channelID,
+ }
+ note.UserID = userID
+
+ if err := stores.Notes.Create(ctx, note); err != nil {
+ log.Printf("⚠️ Failed to create stage note: %v", err)
+ }
+}
+
+// CreateWorkflowAssignment creates an unassigned workflow assignment entry.
+func CreateWorkflowAssignment(ctx context.Context, channelID string, stage int, teamID string) {
+ if database.IsSQLite() {
+ id := store.NewID()
+ _, err := database.DB.ExecContext(ctx, `
+ INSERT INTO workflow_assignments (id, channel_id, stage, team_id)
+ VALUES (?, ?, ?, ?)
+ `, id, channelID, stage, teamID)
+ if err != nil {
+ log.Printf("⚠️ Failed to create workflow assignment: %v", err)
+ }
+ return
+ }
+ _, err := database.DB.ExecContext(ctx, `
+ INSERT INTO workflow_assignments (channel_id, stage, team_id)
+ VALUES ($1, $2, $3)
+ `, channelID, stage, teamID)
+ if err != nil {
+ log.Printf("⚠️ Failed to create workflow assignment: %v", err)
+ }
+}
diff --git a/src/css/workflow.css b/src/css/workflow.css
new file mode 100644
index 0000000..126aeb7
--- /dev/null
+++ b/src/css/workflow.css
@@ -0,0 +1,80 @@
+/* ==========================================
+ * Chat Switchboard — Workflow Components CSS
+ * ========================================== */
+
+/* ── Stage list (admin builder) ────────── */
+
+.wf-stage-row {
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ padding: 8px 10px;
+ border: 1px solid var(--border);
+ border-radius: 6px;
+ margin-bottom: 4px;
+ background: var(--bg-surface);
+ cursor: grab;
+ transition: background 0.15s;
+}
+.wf-stage-row:hover { background: var(--bg-raised); }
+.wf-stage-grip { color: var(--text-3); font-size: 14px; cursor: grab; }
+.wf-stage-ord {
+ width: 22px; height: 22px;
+ display: flex; align-items: center; justify-content: center;
+ border-radius: 50%; background: var(--accent-dim);
+ font-size: 11px; font-weight: 600; color: var(--accent);
+ flex-shrink: 0;
+}
+.wf-stage-name { flex: 1; font-size: 13px; font-weight: 500; }
+.wf-stage-row .badge { font-size: 10px; }
+.wf-stage-row .btn-small { opacity: 0; transition: opacity 0.15s; }
+.wf-stage-row:hover .btn-small { opacity: 1; }
+
+/* ── Queue sidebar ───────────────────── */
+
+.sb-queue-badge {
+ background: var(--accent);
+ color: #fff;
+ border-radius: 10px;
+ padding: 1px 7px;
+ font-size: 11px;
+ font-weight: 600;
+ margin-left: auto;
+}
+.sb-queue-item {
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ padding: 6px 12px;
+ cursor: pointer;
+ border-radius: 6px;
+ font-size: 13px;
+ transition: background 0.15s;
+}
+.sb-queue-item:hover { background: var(--bg-raised); }
+.sb-queue-item.active { background: var(--accent-dim); color: var(--accent); }
+.sb-queue-icon { font-size: 14px; }
+.sb-queue-label { flex: 1; }
+.sb-queue-item .btn-small {
+ opacity: 0; padding: 2px 6px; font-size: 11px;
+ transition: opacity 0.15s;
+}
+.sb-queue-item:hover .btn-small { opacity: 1; }
+
+/* ── Team queue panel ────────────────── */
+
+.wf-queue-panel { padding: 4px 0; }
+.wf-queue-panel h4 { margin: 0 0 12px; font-size: 16px; }
+.wf-queue-panel h5 {
+ margin: 12px 0 6px;
+ font-size: 13px;
+ color: var(--text-2);
+ text-transform: uppercase;
+ letter-spacing: 0.5px;
+}
+
+/* ── Admin badges ────────────────────── */
+
+.badge { font-size: 11px; padding: 2px 8px; border-radius: 10px; background: var(--bg-raised); color: var(--text-2); }
+.badge-ok { background: rgba(46, 160, 67, 0.15); color: #2ea043; }
+.badge-warn { background: rgba(210, 153, 34, 0.15); color: #d29922; }
diff --git a/src/js/ui-admin.js b/src/js/ui-admin.js
index 3ed8653..2f2ec90 100644
--- a/src/js/ui-admin.js
+++ b/src/js/ui-admin.js
@@ -8,6 +8,7 @@
const ADMIN_SECTIONS = {
people: ['users', 'teams', 'groups'],
ai: ['providers', 'models', 'personas', 'roles', 'knowledgeBases', 'memory'],
+ workflows: ['workflows'],
routing: ['health', 'routing', 'capabilities'],
system: ['settings', 'storage', 'extensions', 'channels', 'surfaces'],
monitoring: ['usage', 'audit', 'stats'],
@@ -17,6 +18,7 @@ const ADMIN_LABELS = {
users: 'Users', teams: 'Teams', groups: 'Groups',
providers: 'Providers', models: 'Models', personas: 'Personas', roles: 'Roles', knowledgeBases: 'Knowledge', memory: 'Memory',
health: 'Health', routing: 'Routing', capabilities: 'Capabilities',
+ workflows: 'Workflows',
settings: 'Settings', storage: 'Storage', extensions: 'Extensions', channels: 'Channels', surfaces: 'Surfaces',
usage: 'Usage', audit: 'Audit', stats: 'Stats',
};
@@ -49,6 +51,7 @@ const ADMIN_LOADERS = {
audit: () => UI.loadAuditLog(),
stats: () => UI.loadAdminStats(),
channels: () => UI.loadAdminChannels(),
+ workflows: () => typeof _loadAdminWorkflows === 'function' ? _loadAdminWorkflows() : null,
};
// Find which category a section belongs to
diff --git a/src/js/ui-core.js b/src/js/ui-core.js
index 988d7a6..41d0f24 100644
--- a/src/js/ui-core.js
+++ b/src/js/ui-core.js
@@ -525,11 +525,13 @@ const UI = {
// Chats section shows only direct/group chats not in a project.
// type='channel' and type='dm' belong to the Channels section (App.channels).
+ // type='workflow' belongs to the Queue section (WorkflowQueue).
// Project chats rendered by renderProjectsSection.
let chats = (App.chats || []).filter(c =>
!c.projectId &&
c.type !== 'channel' &&
- c.type !== 'dm'
+ c.type !== 'dm' &&
+ c.type !== 'workflow'
);
if (query) chats = chats.filter(c => (c.title || '').toLowerCase().includes(query));
@@ -625,6 +627,9 @@ const UI = {
// Always keep projects section in sync
this.renderProjectsSection();
+
+ // Refresh workflow queue section (workflow channels filtered out of chat list)
+ if (typeof WorkflowQueue !== 'undefined') WorkflowQueue.refresh();
},
toggleFolder(folderId) {
diff --git a/src/js/workflow-admin.js b/src/js/workflow-admin.js
new file mode 100644
index 0000000..951ef77
--- /dev/null
+++ b/src/js/workflow-admin.js
@@ -0,0 +1,415 @@
+// ==========================================
+// Chat Switchboard — Workflow Builder (Admin)
+// ==========================================
+// Admin panel for managing workflow definitions, stages, and publishing.
+// Registered as ADMIN_LOADERS.workflows in ui-admin.js.
+
+(function() {
+ 'use strict';
+
+ // ── Scaffold HTML ────────────────────────
+ // Injected directly into adminDynamic by the loader since SCAFFOLDING
+ // is scoped inside admin-scaffold.js's IIFE and not accessible here.
+
+ var SCAFFOLD_HTML =
+ '' +
+ '';
+
+ // ── State ───────────────────────────────
+
+ var _currentWf = null;
+ var _editingStageId = null;
+ var _personaCache = []; // [{id, name, icon}]
+
+ // Load personas into the stage editor dropdown.
+ async function _wfLoadPersonaSelect(selectedId) {
+ var sel = document.getElementById('wfStagePersona');
+ if (!sel) return;
+
+ // Fetch once per detail session
+ if (_personaCache.length === 0) {
+ try {
+ var resp = await API.adminListPersonas();
+ _personaCache = (resp.data || resp || []).map(function(p) {
+ return { id: p.id, name: p.name, icon: p.icon || '' };
+ });
+ } catch (e) {
+ // Fall back to user-visible personas
+ try {
+ var resp2 = await API.listPersonas();
+ _personaCache = (resp2.data || resp2 || []).map(function(p) {
+ return { id: p.id, name: p.name, icon: p.icon || '' };
+ });
+ } catch (e2) { /* no personas available */ }
+ }
+ }
+
+ sel.innerHTML = '';
+ _personaCache.forEach(function(p) {
+ var opt = document.createElement('option');
+ opt.value = p.id;
+ opt.textContent = (p.icon ? p.icon + ' ' : '') + p.name;
+ sel.appendChild(opt);
+ });
+
+ if (selectedId) sel.value = selectedId;
+ }
+
+ // ── Loader (called from ADMIN_LOADERS.workflows) ──
+
+ window._loadAdminWorkflows = async function() {
+ // Self-scaffold: inject our HTML into adminDynamic
+ var target = document.getElementById('adminDynamic');
+ if (target && !document.getElementById('wfAdminList')) {
+ target.innerHTML = SCAFFOLD_HTML;
+ }
+
+ const list = document.getElementById('wfAdminList');
+ const detail = document.getElementById('wfAdminDetail');
+ if (!list) return;
+
+ detail.style.display = 'none';
+ list.style.display = '';
+
+ try {
+ const resp = await API.listWorkflows();
+ const wfs = resp.data || resp || [];
+
+ if (wfs.length === 0) {
+ list.innerHTML =
+ '
+ 
+
+ {{else}}
+ {{if .Data.PersonaIcon}}{{.Data.PersonaIcon}}{{else}}⚡{{end}}
+ {{end}}
+
+ {{.Data.Name}}
+ + {{if .Data.Branding.Tagline}} +{{.Data.Branding.Tagline}}
+ {{end}} + + {{if .Data.Description}} +{{.Data.Description}}
+ {{end}} + + {{if .Data.PersonaName}} +
+
+ You'll be chatting with {{.Data.PersonaName}}
+
+ {{end}}
+
+
+
+ {{if .Data.ResumeURL}}
+ Resume previous session →
+ {{end}}
+
+
+ No workflows yet
' +
+ '';
+ return;
+ }
+
+ let html = '' +
+ '' + wfs.length + ' workflow(s)' +
+ '
';
+ html += '