apiVersion: crewship/v1                 # required — always crewship/v1
kind: Routine                           # required — literal "Routine"
metadata:
  name: <human-readable label>          # required — UI display name
  slug: <kebab-case>                    # required — workspace-unique idempotency key
  description: <optional>               # optional — surfaces in routine list
  labels:
    crew: <crew-slug>                   # REQUIRED — parent crew the routine belongs to.
                                        # Every step.agent_slug must be an agent that
                                        # is a member of this crew (server enforces
                                        # at apply time).

spec:
  # ---- routine DSL (same as routine.v1.json) ----
  dsl_version: "1.0"                    # required — DSL schema version, currently "1.0"
  description: <optional>               # routine-level description (one-line)
  inputs:                               # optional — declared input parameters
    - name: <identifier>
      type: string|integer|number|boolean|array|object
      required: false
      default: <value>
      description: <optional>
  steps:                                # required — at least one step
    - id: <unique within routine>
      type: agent_run|call_pipeline|http|code|wait|transform|notify|script|query
      # agent_run-specific:
      agent_slug: <agent-slug-in-parent-crew>
      prompt: <template-substitutable string>
      # ...other per-type fields documented in schemas/routine.v1.json
  credentials_required:                 # optional — typed credential references
    - { type: <cred-type>, scope: <optional-scope> }
  estimated_cost_usd: 0.05              # optional — author estimate
  estimated_duration_seconds: 180       # optional — author estimate
  max_cost_usd: 0.50                    # optional — runtime cost cap (aborts run)
  egress_targets:                       # optional — enforced at run time for
    - <hostname>                        #   `http` steps + hooks (redirects too);
                                        #   omitted = unrestricted at this layer.
                                        #   The authoring crew's network policy
                                        #   (restricted mode) applies on top.
  slash:                                # optional — offer as /<slug> in chat + repl
    enabled: true                       # required to appear; absent/false = not offered
    label: <palette row text>           # optional — falls back to metadata.name, then slug
    label_cs: <Czech label>             # optional — falls back to label
    icon: <lucide-icon-name>            # optional — lowercase kebab-case, e.g. receipt

  # ---- any other routine.v1.json field ----
  # Keys this page does not list ride through untouched — guardrails,
  # integrations_required, concurrency_key, max_concurrent, outputs,
  # display_name, agentless, hooks, eval, resources, execution_tier,
  # parallelism. `schemas/routine.v1.json` is the full list; run
  # `crewship routine schema` to print it.
  guardrails:                           # example of a pass-through field
    input: sanitize

  # ---- manifest-only nested triggers ----
  schedules:                            # optional — 0..N cron triggers
    - name: <schedule label>            # required, unique within this routine
      cron: "0 * * * *"                 # required — 5-field cron expr (Descriptor allowed)
      timezone: Europe/Prague           # required — IANA timezone name
      enabled: true                     # optional, default true
      inputs:                           # optional — override routine defaults at trigger time
        <input-name>: <value>

  webhook:                              # optional — at most one per routine
    enabled: true                       # required
    require_token: true                 # optional, default true (false = open dispatch)
    token_env_ref: WEBHOOK_TOKEN_ENV    # optional — name of a workspace env var
                                        # carrying the public token. Surfaced as a
                                        # warning at Plan time if it does not resolve.

apiVersion: crewship/v1
kind: Routine
metadata:
  name: Echo
  slug: echo
  labels:
    crew: my-crew
spec:
  dsl_version: "1.0"
  steps:
    - id: hello
      type: code
      code:
        runtime: cel          # wired, token-zero (expr | cel only; bash/python/go are rejected)
        code: '"hi"'

apiVersion: crewship/v1
kind: Routine
metadata:
  name: Discord hourly sync
  slug: discord-sync
  description: Pull recent Discord channel activity and summarize via Claude
  labels:
    crew: uo-outlands       # the routine runs in the context of this crew

spec:
  dsl_version: "1.0"
  description: Hourly Discord pull + LLM summary

  inputs:
    - name: channels
      type: string
      required: false
      default: all
      description: Comma-separated channel ids, or "all" to pull every channel.

  steps:
    # Shell work runs via an agent with shell-tool access — `type: code`
    # only wires the token-zero expr/cel runtimes (bash/python/go are
    # rejected at author time; see "Code steps" below).
    - id: pull
      type: agent_run
      agent_slug: trapper             # MUST be a member of crew "uo-outlands"
      prompt: |
        Run exactly one shell command and return its raw JSON stdout:

            dce sync --channels "{{ inputs.channels }}" --json
      timeout_seconds: 120

    - id: summarize
      type: agent_run
      agent_slug: trapper             # MUST be a member of crew "uo-outlands"
      needs: [pull]
      prompt: |
        Summarize the following Discord activity in 5 bullets,
        flagging anything that requires moderator follow-up.

        Raw events:
        {{ steps.pull.output }}
      complexity: fast
      validation:
        min_length: 100
        must_not_contain:
          - "ANTHROPIC_API_KEY"
          - "DISCORD_BOT_TOKEN"

  credentials_required:
    - { type: GENERIC_SECRET, scope: discord-bot }
    - { type: API_KEY,        scope: anthropic   }

  estimated_cost_usd: 0.05
  estimated_duration_seconds: 180
  max_cost_usd: 0.50

  egress_targets:
    - discord.com
    - cdn.discordapp.com

  # Two schedules: production hourly + a low-frequency weekly digest.
  schedules:
    - name: Hourly
      cron: "0 * * * *"
      timezone: Europe/Prague
      enabled: true
      inputs:
        channels: all

    - name: Weekly digest
      cron: "0 9 * * MON"
      timezone: Europe/Prague
      enabled: true
      inputs:
        channels: announcements,community

  # One webhook for inbound Vendor invocations (e.g. third-party
  # alert sources). require_token: true (default) means the webhook
  # token must match the value of $DISCORD_WEBHOOK_TOKEN at dispatch
  # time; setting require_token: false would make the endpoint
  # publicly invokable (only safe behind a private network gateway).
  webhook:
    enabled: true
    require_token: true
    token_env_ref: DISCORD_WEBHOOK_TOKEN

steps:
  - id: probe
    type: code
    code:
      runtime: expr
      # body is rendered first ({{ inputs.x }} substituted), then
      # evaluated. Operators: >  >=  <  <=  ==  !=
      code: "{{ inputs.spend_usd }} > {{ inputs.threshold_usd }}"

steps:
  - id: spike
    type: code
    code:
      runtime: cel
      # Real logic in one deterministic, token-zero step:
      code: 'inputs.spend_usd > inputs.threshold_usd && inputs.region in ["eu", "us"]'

pipeline: step "probe" (code) runtime "bash" has no wired runner in this
build — use runtime: expr or cel for agentless logic, or convert to
type: agent_run with a shell-tool-enabled agent

steps:
  - id: probe
    type: code
    code:
      runtime: bash
      code: |
        curl -sS https://www.seznam.cz -o /tmp/page.html -w '%{http_code}'

steps:
  - id: probe
    type: agent_run
    agent_slug: sre-lead
    prompt: |
      Run exactly one shell command and report the http status code:

          curl -sS https://www.seznam.cz -o /tmp/page.html -w '%{http_code}'

      Reply on one line: `OK <code>` if status is 200, otherwise
      `BREACH <code>`.

steps:
  - id: parse
    type: script
    script:
      path: scripts/parse_vypis.py     # under /crew/shared; traversal rejected
      interpreter: python3             # optional — inferred from .py/.sh/.js/…
      args: ["{{ inputs.file }}"]      # template-substituted; passed as argv
      env:
        MODE: "{{ inputs.mode }}"      # extra env (rendered)

spec:
  files:
    - src: scripts/parse_vypis.py
      dest: shared/scripts/parse_vypis.py

$ crewship routine run release-with-approval
Run run_abc: WAITING (12ms, $0.0021)
  paused at approval step: approve
  approve: crewship routine waitpoints approve <token> --comment "LGTM"
  reject:  crewship routine waitpoints reject <token>

crewship routine waitpoints list                 # find the pending token
crewship routine waitpoints approve <token>      # → run resumes to COMPLETED
crewship routine waitpoints reject  <token>      # → run resumes and FAILS (denied)

crewship routine run cost-spike-probe \
  --tag prod --tag billing \
  --metadata '{"source":"manual","ticket":"OPS-42"}'

crewship routine replay <run_id>

steps:
  - id: notify
    if: "{{ env.is_replay }}"   # only on replays — or invert to skip on replay
    type: agent_run
    ...

crewship routine errors                       # list fingerprint groups
crewship routine bulk-replay --fingerprint <fp>   # replay the whole group after a fix

crewship routine waitpoints <token>     # prints "Callback URL: …"

curl -X POST <callback_url> -d '{"approved":true,"payload":{"result":"ok"}}'

crewship routine run my-routine --batch inputs.jsonl --tag nightly
crewship routine runs my-routine --tag batch:<id>

crewship routine step-override set my-routine summarize \
  --prompt "Summarize in 3 bullets, lead with the risk." --model smart
crewship routine step-override list my-routine
crewship routine step-override clear my-routine summarize

# fire 60s from now, expire if not dispatched within 5 min, high priority
crewship routine run my-routine --delay 60 --ttl 300 --priority 9

# coalesce a burst: repeated triggers with the same key collapse into one
crewship routine run my-routine --debounce-key vendor-42 --debounce-window 30 --debounce-max 300

crewship routine pending list            # not-yet-fired deferred triggers
crewship routine pending cancel <id>     # cancel before it fires

spec:
  dsl_version: "1.0"
  hooks:
    before_all:                 # setup — its FAILURE aborts the run
      id: claim
      type: http
      http: { method: POST, url: "https://ops.example.com/claim", credential_ref: { type: GENERIC_SECRET } }
    after_all:                  # on COMPLETED — best-effort
      id: release
      type: http
      http: { method: POST, url: "https://ops.example.com/release" }
    on_failure:                 # on FAILED — best-effort cleanup
      id: alert
      type: http
      http: { method: POST, url: "https://ops.example.com/alert" }
  steps:
    - id: work
      type: agent_run
      ...

spec:
  inputs:
    - name: obdobi
      type: string
      description: Billing period, YYYY-MM. Empty means the previous month.
    - name: ucetnictvi_root
      type: string
      default: "Unify - Účetnictví"
  slash:
    enabled: true
    label: Monthly accounting pack
    label_cs: Účetní podklady za měsíc
    icon: receipt

crewship › /msn-etn-podklady obdobi=2026-07

crewship › /msn-etn-podklady obdobi=2026-07
[/msn-etn-podklady] ✓

You:    run the monthly accounting pack
Agent:  Which period? (obdobi, YYYY-MM — leave it and it uses last month.)
        I'll use the defaults for ucetnictvi_root ("Unify - Účetnictví")
        and vypis_odesilatel ("info@rb.cz") unless you say otherwise.
You:    2026-07
Agent:  [runs msn-etn-podklady with obdobi=2026-07]