One file can hold the complete business system.

secret editorial_ops {
  label: "Editorial vendor keys"
  vars: [ OPENROUTER_API_KEY ]
}

database articles {
  label: "Editorial articles"
  description: "Drafts, review state, and published pieces for the editorial desk."
  schema: @prisma {
    enum ArticleStatus {
      SUBMITTED
      SCREENED
      PUBLISHED
    }

    model Article {
      id          Int           @id @default(autoincrement())
      title       String
      body        String
      authorEmail String
      status      ArticleStatus @default(SUBMITTED)
      summary     String?
      flags       String[]
      submittedAt DateTime      @default(now())
      publishedAt DateTime?

      @@map("articles")
    }
  }

  connection app {
    label: "Editorial application connection"
  }
}

schema submission_input {
  label: "Article submission"
  schema: @json {
    {
      "type": "object",
      "required": ["title", "body", "author_email"],
      "properties": {
        "title": { "type": "string", "title": "Title" },
        "body": { "type": "string", "title": "Body" },
        "author_email": { "type": "string", "title": "Author email", "format": "email" }
      },
      "additionalProperties": false
    }
  }
}

form article_submission {
  label: "Article submission"
  description: "Submit a draft for editorial review."
  enabled: true
  schema: submission_input
}

trigger on_submission {
  form:article_submission -> publish_article
  enabled: true
}

workflow publish_article {
  label: "Publish article"
  description: "Screen a draft with AI, hold it for an editor, then publish and announce."

  root {
    type: code
    label: "Normalize submission"
    inputSchema: submission_input
    outputSchema: @json {
      {
        "type": "object",
        "required": ["title", "body", "author_email", "word_count"],
        "properties": {
          "title": { "type": "string" },
          "body": { "type": "string" },
          "author_email": { "type": "string" },
          "word_count": { "type": "integer" }
        },
        "additionalProperties": false
      }
    }
    code: @ts {
      const { title, body, author_email } = context.nodes.root.input
      return {
        title: title.trim(),
        body: body.trim(),
        author_email: author_email.toLowerCase().trim(),
        word_count: body.split(/\s+/).length,
      }
    }
  }

  node screen {
    type: ai
    kind: object
    label: "Screen draft"
    model: "google/gemini-2.5-flash"
    schema: @json {
      {
        "type": "object",
        "required": ["summary", "flags"],
        "properties": {
          "summary": { "type": "string" },
          "flags": { "type": "array", "items": { "type": "string" } }
        }
      }
    }
    prompt: @ts {
      const { title, body } = context.nodes.root.output
      return [
        "Summarize this draft in one sentence, then list editorial concerns.",
        "Flag missing attribution, unsourced claims, and inflammatory language.",
        "Return an empty flags array when the draft is clean.",
        "",
        "Title: " + title,
        "Body: " + body,
      ].join("\n")
    }
  }

  node save_draft {
    type: database
    label: "Save screened draft"
    database: articles
    operation: insert
    run: @ts {
      const draft = context.nodes.root.output
      const { summary, flags } = context.nodes.screen.output
      const article = await context.db.articles.article.create({
        data: {
          title: draft.title,
          body: draft.body,
          authorEmail: draft.author_email,
          status: "SCREENED",
          summary,
          flags,
        },
      })
      return { id: article.id }
    }
  }

  node editorial_review {
    type: code
    label: "Editor review"
    code: @ts {
      const { title, word_count } = context.nodes.root.output
      const { summary, flags } = context.nodes.screen.output
      return { title, word_count, summary, flags }
    }
    review: {
      enabled: true
      title: "Editorial review"
      description: "Approve the draft, or send it back with notes."
      schema: @json {
        {
          "type": "object",
          "required": ["decision"],
          "properties": {
            "decision": { "type": "string", "title": "Decision", "enum": ["approve", "revise"] },
            "editor_notes": { "type": "string", "title": "Editor notes" }
          },
          "additionalProperties": false
        }
      }
      actions: [
        { id: "approve", label: "Approve & publish", outcome: "approve" },
        { id: "revise", label: "Request revisions", outcome: "reject" }
      ]
    }
  }

  node publish {
    type: database
    label: "Mark published"
    database: articles
    operation: update
    run: @ts {
      const { id } = context.nodes.save_draft.output
      const article = await context.db.articles.article.update({
        where: { id },
        data: { status: "PUBLISHED", publishedAt: new Date() },
      })
      return { id: article.id, title: article.title }
    }
  }

  node announce {
    type: integration
    label: "Announce in Slack"
    connection: editorial_slack
    action: slack_post_message
    params: @ts {
      return {
        channel: "#editorial",
        text: "Published: " + context.nodes.publish.output.title,
      }
    }
  }

  node published {
    type: code
    label: "Return published article"
    schema: @json {
      {
        "type": "object",
        "required": ["id", "title"],
        "properties": {
          "id": { "type": "integer" },
          "title": { "type": "string" }
        },
        "additionalProperties": false
      }
    }
    code: @ts {
      return context.nodes.publish.output
    }
  }

  flow {
    root -> screen
    screen -> save_draft
    save_draft -> editorial_review
    editorial_review -> publish
    publish -> announce
    announce -> published
  }
}

action slack_post_message {
  label: "Post message"
  description: "Post a message to a Slack conversation."
  provider: slack
  method: POST
  path: "/chat.postMessage"
  encoding: form
  scopes: ["chat:write"]
  input: @json {
    {
      "type": "object",
      "required": ["channel", "text"],
      "properties": {
        "channel": { "type": "string" },
        "text": { "type": "string" }
      },
      "additionalProperties": false
    }
  }
  output: @json {
    {
      "type": "object",
      "required": ["ok"],
      "properties": {
        "ok": { "type": "boolean" },
        "ts": { "type": "string" }
      },
      "additionalProperties": true
    }
  }
}

connection editorial_slack {
  label: "Editorial Slack"
  provider: slack
}

skill editorial_voice {
  name: "editorial-voice"
}

agent editor_assistant {
  label: "Editor assistant"
  description: "Answers questions about the queue and publishes drafts an editor cleared."
  secrets: editorial_ops
  provider: openrouter
  model: "openai/gpt-4o-mini"
  maxSteps: 8
  skills: [editorial_voice]
  tools: [publish_article]
  system: @ts {
    return [
      "You help the editorial desk move drafts through review.",
      "Open the editorial-voice skill before judging tone, attribution, or house style.",
      "Never publish a draft an editor has not approved.",
    ].join("\n")
  }
}

channel editorial_room {
  label: "Editorial room"
  platform: swirls
  agent: editor_assistant
  enabled: true
  mode: mention
}

role editorial {
  description: "Editorial staff"
  match {
    department: "editorial"
  }
}

policy {
  allow editorial -> agent editor_assistant {
    workflows: [publish_article]
  }
}

app editorial_desk {
  label: "Editorial Desk"
  description: "The queue, the approvals, and the assistant in one place."
  icon: "newspaper"

  audience {
    admission: invite
    auth: oidc
    idp: editorial_clerk
  }

  nav {
    section "Desk" {
      page: queue
      page: approvals { label: "Awaiting review" }
    }
    section "Team" {
      page: room { label: "Editorial room" }
    }
  }

  page queue {
    label: "Queue"
    icon: "inbox"
    viewport: full
    render: @openui {
      root = Gutter([
        TableEditor("articles", "articles", {
          title: "Review queue",
          fill: true,
          columns: ["title", "status", "summary", "flags"]
        })
      ], "lg")
    }
  }

  page approvals {
    label: "Awaiting review"
    icon: "clipboard-check"
    reviews: [publish_article]
  }

  page room {
    icon: "hash"
    channel: editorial_room
  }
}