> ## Documentation Index
> Fetch the complete documentation index at: https://deepline.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# deepline plays

> Search, validate, run, and manage cloud plays.

## plays

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays [options] [command]

Search, validate, run, and manage cloud plays.

Options:
  -h, --help                          display help for command

Commands:
  resume-submission [options] <path>  Inspect or explicitly resubmit the same
                                      saved admission intent, preserving its run
                                      ID and original revision.
  check [options] <target>            Check a local play file or named/prebuilt
                                      play contract.
  settings                            Read and change Play settings by name and
                                      value.
  trigger                             Read and change one Play’s cron and
                                      webhook triggers. `plays triggers` lists
                                      every trigger.
  get [options] <target>              Fetch full play details or materialize a
                                      saved source bundle.
  triggers [options]                  List a bounded page of triggers, or read
                                      one trigger’s recent history.
  cost [options] <play>               Estimate one saved or prebuilt Play in the
                                      current workspace.
  list [options]                      List saved and prebuilt plays.
  activity [options]                  Count Play runs and delivered Monitor
                                      findings by day.
  pin [options] <target>              Pin an org-owned play to the top of play
                                      listings.
  unpin [options] <target>            Remove an org-owned play from the pinned
                                      group.
  search [options] [task]             Deprecated. Use deepline search --type
                                      <types>.
  grep [options] <query>              Search active org-owned Plays through
                                      Convex full-text search.
  versions [options]                  List revisions for a named play.
  save [options] <file>               Save or update a local Play working draft
                                      without publishing it.
  deploy [options] [directory]        Deploy every play in a directory as one
                                      unit (all go live together, or none).
  deployments [options] [id]          Deployment history for this workspace;
                                      pass an id for one deployment and its
                                      plays.
  publish [options] <target>          Promote a saved play revision or publish a
                                      local play file.
  set-live [options] <target>         Promote a saved revision or publish a
                                      local play file.
  delete [options] <target>           Move an org-owned play to Trash and stop
                                      its triggers.
  restore [options] <target>          Restore an org-owned play from Trash.
  share                               Manage a play's public, unlisted share
                                      page (advanced — exposes play code).
  help [command]                      display help for command
```

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Explanation:
  Purpose:
    Durable workflows. Prebuilt plays are Deepline-maintained waterfalls such as
    name-and-domain-to-email, person-linkedin-to-email, person-to-phone, and
    company search, each with a single-row and a -batch (CSV) variant. A play
    you write is one TypeScript file.
  When:
    Any job with rows, or any job that chains providers. A play reuses finished
    rows on rerun, so a failed run can be resumed instead of repaid.
  The sequence:
    search "<input you have -> result you need>"   find the play
    describe <ref>                required input, CSV columns, output fields
    plays cost <ref>              per-row or per-run credit estimate
    run <ref> --input '{"csv":"file.csv"}' --csv-out out.csv   run it, save rows
  Writing a play:
    Start from code that already works, not a blank file.
    plays get prebuilt/<name> --source --out my.play.ts
                                  copy the closest prebuilt and edit the copy
    plays check my.play.ts        validate after every edit; free
    run my.play.ts --input '{...}'                 run the local file
    plays publish my.play.ts      make it live for run <name> and triggers
    run -e "<code>"               run code inline as a play function's body
                                  (input holds --input), like python -c
    A play is a default-exported async function of its input; the file name
    is its default name:
      import deepline from 'deepline';
      export default async function (input: { domain: string }) {
        const company = await deepline.tools.execute({ id, tool, input, description });
        return { company };
      }
    The parameter's type is the input contract; the returned object is the
    result.
    An optional export const config = { name, description, cron, webhook,
    runtime }; at the top of the file sets the name, triggers and runtime.
    --help --verbose lists the authoring rules.
  Auditing plays:
    plays list                    every saved play
    plays versions --name <play>  its revisions, and which one is live
    plays get <play> --source --out <dir>          a revision's source (--live,
                                  --working, or --revision <n>)
    plays check <file>            deprecated or invalid usage, one hint per
                                  issue; read-only and free
    plays triggers                every cron and webhook trigger
  Cost:
    search, describe, list, check, and get are free; run spends credits.

  Authoring rules:
    Reach the outside world only through deepline: deepline.csv,
      deepline.dataset, deepline.tools.execute, deepline.runPlay, deepline.step,
      deepline.fetch, deepline.secrets, deepline.customerDb, and deepline.log.
      No fs, raw fetch, or shell commands, also not inside deepline.step. Local
      nondeterministic work such as Date.now or Math.random goes inside
      deepline.step. Call deepline.* only in the play file; pass it to helpers.
    A run can be interrupted and replayed from the top; every finished step
      and tool call then returns its saved result. So the play name, each
      dataset key, step id, fetch key, and tools.execute id is a fixed string
      literal, and renaming one pays for that work again.
    Rows: deepline.dataset('key', rows).withColumn('name', (row) => ...)
      .run({ key: 'domain' }); call deepline.* inside the column too. Use a business identifier as the row key. Put
      one paid call in a column, and shaping, status, and miss_reason in
      separate plain columns after it. Return the dataset for anything that
      should export as CSV.
    Dataset handles are async: await rows.count(), rows.first(),
      rows.peek(n), rows.materialize(n), or for await. Array methods on a
      handle fail plays check.
    Tool calls: deepline.tools.execute({ id, tool, input, description,
      staleAfterSeconds }). In authoring edition 11, choose freshness explicitly:
      0 for fresh logical work, a positive integer for the maximum reusable
      result age in seconds, or null for indefinite result reuse. A matching
      completed operation receipt can still recover that operation after resume.
      Read
      results the way describe lists them:
      result.fields.<name>.value for a value whose meaning is known, also by
      field id (result.fields.person.email.value). .value throws when there are
      several; .values is always an array;
      result.extractedValues.<name>.get() for other declared values. Anything
      else is in result.response, the provider's response with its nesting kept.
      For a list, result.rows() gives one record per item, in the same format
      for every tool: row.fields.email.value, and row.response for the rest.
      Name the list when the tool declares several: result.rows('people').
    Reuse before rebuilding: deepline.runPlay(key, 'prebuilt/<name>', input,
      { description }) runs a
      prebuilt as one stage. Independent calls run together with Promise.all;
      a call that needs another's result waits for it.
    Failures: catch only ProviderTransientError, and only when another
      provider can answer the same question. Keep the last provider outside
      the catch so an exhausted waterfall fails loudly. Never branch on an
      error message.
    External APIs: deepline.fetch with a fixed key, and credentials through
      deepline.secrets.bearer(...) or deepline.secrets.header(...), stored
      with deepline secrets set. res.json is a property, not a method; check
      res.ok. A play cannot loop deepline.fetch over pages: fan out over rows
      with deepline.dataset, or
      call one endpoint that returns the whole result.
    Triggers: export const config = { cron: { schedule, timezone, input } };
      or { webhook: {} }. A cron run receives {} unless cron.input is written
      inline; it is pinned with the published revision.
    Runtime: The default Play runtime is 30 minutes. Standard uses 1 GiB / 1 CPU.
      Set runtime.size to 'standard' or '1gb' (1 GiB / 1 CPU), 'large' or '4gb'
      (4 GiB / 2 CPU), or 'xlarge' or '8gb' (8 GiB / 4 CPU).
      Each alias selects the same profile and price as its named size.
      Compute pricing follows the workspace plan.
      Use deepline billing quote for the session ceiling.
      Set runtime.timeout to extend a run up to 4h.
      For large datasets, keep working sets bounded and checkpoint progress;
      inline ctx.runPlay shares parent memory, while ctx.runPlayAsync starts an
      independent run. A larger profile does not make a job resumable. This is
      not the CLI wait timeout.
    Recurring sourcing: .run({ key: 'domain', mode: 'net_new' }) returns only
      rows the table has not seen before.
    Results: project each answer into flat columns (the value, its source,
      whether it was validated, the outcome, the reason) and keep evidence
      under _dl_meta, including result._metadata.execution.receiptKey. Unknown
      stays null, not false.
    Diagram: a /** @mermaid */ block at the top of the play draws it in the
      dashboard, with // @mermaid-node <id> out:"<identifier>" above the
      statement each box stands for. plays check validates it.
```

## plays resume-submission

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays resume-submission [options] <path>

Inspect or explicitly resubmit the same saved admission intent, preserving its
run ID and original revision.

Options:
  --inspect   Read the local submission identity only; no API calls or execution
  --json      Emit the identity or admission response as JSON
  -h, --help  display help for command
```

## plays check

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays check [options] <target>

Check a local play file or named/prebuilt play contract.

Options:
  --full           Include compiler diagnostics
  --json [fields]  Emit JSON, optionally selecting comma-separated dotted fields
  -h, --help       display help for command
```

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Explanation:
  Purpose:
    Validate a play contract without starting a run: a local .play.ts file is
    bundled and checked, a named or prebuilt play is confirmed discoverable.
  When:
    Before running a local play file, and after editing one. Free, so run it
    every time.
  Input:
    A local path ending in .play.ts, or a play reference. --json prints JSON.
  Output (JSON):
    valid (boolean), target, name, reference, inputSchema, outputSchema,
    runtimeLimit, note, and for local files any errors or warnings with the
    repair steps.
  Cost:
    Free.
  Avoid:
    valid true does not mean the input you plan to pass is valid; describe
    shows the required fields.
```

## plays settings

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays settings [options] [command]

Read and change Play settings by name and value.

Options:
  -h, --help             display help for command

Commands:
  describe [options]     List setting names, values, examples and defaults; no
                         authentication required.
  get [options]          Read all settings, or one setting selected with --name.
  set [options]          Set one setting without creating or publishing a
                         revision.
  reset [options]        Reset one setting to its schema default.
  paths [options]        List existing locations (one bounded page).
  move-folder [options]  Move or rename a folder. Every Play below it moves and
                         keeps its subfolders. Retry-safe: rerun to finish an
                         interrupted move.
  help [command]         display help for command
```

## plays settings describe

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays settings describe [--name <setting>] [options]

List setting names, values, examples and defaults; no authentication required.

Options:
  --name <setting>  Describe one setting. Available: path, displayName
  --json            Emit JSON
  -h, --help        display help for command
```

## plays settings get

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays settings get --play <play> [--name <setting>] [options]

Read all settings, or one setting selected with --name.

Options:
  --play <play>     Play to read
  --name <setting>  Read one setting. Available: path, displayName
  --json            Emit JSON
  -h, --help        display help for command
```

## plays settings set

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays settings set --play <play> --name <setting> --value <value> [options]

Set one setting without creating or publishing a revision.

Options:
  --play <play>     Play to update
  --name <setting>  Setting name. Available: path, displayName
  --value <value>   New value; see settings describe --name <setting>
  --dry-run         Show the patch without changing settings
  --json            Emit JSON
  -h, --help        display help for command
```

## plays settings reset

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays settings reset --play <play> --name <setting> [options]

Reset one setting to its schema default.

Options:
  --play <play>     Play to update
  --name <setting>  Setting name. Available: path, displayName
  --dry-run         Show the patch without changing settings
  --json            Emit JSON
  -h, --help        display help for command
```

## plays settings paths

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays settings paths [options]

List existing locations (one bounded page).

Options:
  --root <person|team>  Filter by root
  --limit <n>           Plays to inspect, 1–100 (default: "50")
  --cursor <cursor>     Continue from a previous page
  --json                Emit JSON
  -h, --help            display help for command
```

## plays settings move-folder

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays settings move-folder --from <path> --to <path> [--owner <user-id>] [options]

Move or rename a folder. Every Play below it moves and keeps its subfolders.
Retry-safe: rerun to finish an interrupted move.

Options:
  --from <path>      Folder to move, e.g. team/Research
  --to <path>        Its new path including its name, e.g. team/Archive/Research
  --owner <user-id>  Personal-root owner, when several people have the --from
                     folder or --to is person
  --dry-run          Show the planned moves without changing settings
  --json             Emit JSON
  -h, --help         display help for command
```

## plays trigger

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays trigger [options] [command]

Read and change one Play’s cron and webhook triggers. `plays triggers` lists
every trigger.

Options:
  -h, --help                           display help for command

Commands:
  get [options]                        Show the cron and webhook triggers of a
                                       Play.
  set-cron|set-schedule [options]      Schedule the Play (replaces any existing
                                       schedule).
  clear-cron|clear-schedule [options]  Remove the schedule.
  set-webhook [options]                Turn on the webhook trigger. Without
                                       --auth, keeps the current authentication.
  clear-webhook [options]              Remove the webhook trigger and retire its
                                       URL.
  help [command]                       display help for command
```

## plays trigger get

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays trigger get [options]

Show the cron and webhook triggers of a Play.

Options:
  --play <play>  Play to read
  --json         Emit JSON
  -h, --help     display help for command
```

## plays trigger set-cron

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays trigger set-cron|set-schedule [options]

Schedule the Play (replaces any existing schedule).

Options:
  --schedule <cron>         5-field cron, e.g. "0 9 * * 1-5"
  --timezone <iana>         IANA timezone; default UTC
  --input <json>            Static JSON object passed to every cron run
  --play <play>             Play to change
  --expected-revision <id>  Refuse the change if the live revision is no longer
                            this one
  --dry-run                 Show the change without publishing
  --json                    Emit JSON
  -h, --help                display help for command
```

## plays trigger clear-cron

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays trigger clear-cron|clear-schedule [options]

Remove the schedule.

Options:
  --play <play>             Play to change
  --expected-revision <id>  Refuse the change if the live revision is no longer
                            this one
  --dry-run                 Show the change without publishing
  --json                    Emit JSON
  -h, --help                display help for command
```

## plays trigger set-webhook

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays trigger set-webhook [options]

Turn on the webhook trigger. Without --auth, keeps the current authentication.

Options:
  --auth <mode>                none, standard (Standard Webhooks), svix, or hmac
                               (legacy sha256)
  --secret <name>              Deepline Secret name; repeat for rotation
                               (standard/svix)
  --header <name>              Signature header (hmac)
  --signature-prefix <prefix>  Signature prefix (hmac)
  --tolerance-seconds <n>      Replay window in seconds (standard/svix), default
                               300
  --play <play>                Play to change
  --expected-revision <id>     Refuse the change if the live revision is no
                               longer this one
  --dry-run                    Show the change without publishing
  --json                       Emit JSON
  -h, --help                   display help for command
```

## plays trigger clear-webhook

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays trigger clear-webhook [options]

Remove the webhook trigger and retire its URL.

Options:
  --play <play>             Play to change
  --expected-revision <id>  Refuse the change if the live revision is no longer
                            this one
  --dry-run                 Show the change without publishing
  --json                    Emit JSON
  -h, --help                display help for command
```

## plays get

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays get [options] <target>

Fetch full play details or materialize a saved source bundle.

Options:
  --json               Emit JSON output
  --source             Read source; prints single-file Plays or combines with
                       --out to write the full bundle
  --out <path>         Write source to a file or, for multi-file Plays, a
                       directory
  --working            Read the current working draft source (default)
  --live               Read the live revision source
  --revision <number>  Read a specific revision source
  -h, --help           display help for command
```

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Explanation:
  Purpose:
    Full metadata for a play: revisions, source, triggers, and latest runs.
  When:
    Only when describe is not enough: reading the source (--source --out
    file.play.ts), checking revisions, or auditing a saved play.
  Input:
    The play reference. --source prints or writes the source; --working,
    --live, --revision <n> pick which source.
  Output (JSON):
    The play record with revision and trigger metadata; with --source, the
    TypeScript source.
  Cost:
    Free.
```

## plays triggers

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays triggers [options]

List a bounded page of triggers, or read one trigger’s recent history.

Options:
  --cursor <cursor>        Continue the trigger inventory
  --binding <id>           Read history for this trigger binding
  --history-limit <count>  Recent history cap, 1–30 (default: "10")
  --json                   Emit JSON output
  -h, --help               display help for command
```

## plays cost

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays cost [options] <play>

Estimate one saved or prebuilt Play in the current workspace.

Options:
  --json      Emit the cost estimate as JSON
  -h, --help  display help for command
```

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Explanation:
  Purpose:
    Read the advisory cost estimate for one saved or prebuilt Play.
  Input:
    <play> is a bare name or qualified reference. --json prints the exact result.
  Output:
    reference, costEstimate, and for prebuilts observedCost. Estimates include
    the output unit, observed or static range, sample size and compute ceiling.
  Cost:
    Read-only. Uses the current workspace's pricing; does not start a run.
```

## plays list

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays list [options]

List saved and prebuilt plays.

Options:
  --limit <count>            Page size
  --cursor <cursor>          Continue a previous page
  --show-cost                Include the per-row or per-run cost estimate
  --summary                  Load metadata without authored source or revision
                             payloads
  --json                     Emit JSON output
  --categories <categories>  Filter by comma-separated canonical tool categories
  --tag <tag...>             Filter by the job the play does: smb,
                             find-prospects, qualify, contact-info, signals
  -h, --help                 display help for command
```

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Explanation:
  Purpose:
    Inventory of saved and prebuilt plays, one bounded page at a time.
    Add --show-cost for estimates across the page.
  When:
    To price a catalog page: plays list --show-cost, then read the
    cost estimate line for the play, or in JSON observedCost (prebuilts) or
    costEstimate.
  Input:
    --show-cost adds estimates. --summary loads metadata without source or
    revision payloads. --limit and --cursor page. --categories
    filters by tool category. --json prints JSON.
  Output (JSON):
    plays[] with playKey, reference, displayName, description, origin,
    runCount, lastRun, and with --show-cost: costEstimate {status, unit
    ("row" or "run"), lowCredits, highCredits, source, sampleRunCount} or
    {status: "unavailable", reason, message}, and for prebuilts also
    observedCost, the same object search returns; count, has_more, next_cursor,
    next (the next-page command), render.sections with a "cost estimate:"
    line per play.
  Cost:
    Free.
  Avoid:
    For a prebuilt, search and describe show the same observedCost; for your
    own plays only this command estimates cost.

  Pricing a run:
    Multiply lowCredits..highCredits (observedCost: avgCredits, or the typical
    range before runs are observed) by the row count when unit is "row", or
    use it directly when unit is "run". Compare with the billing balance.
    When the estimate is unavailable, run a two-row slice first and
    read its actual spend with billing usage --run-id <run-id>.
  Output fields:
    costEstimate.source      "observed" (from past runs; shown with ~) or
                             "static" (a hand-written range or the play's
                             declared tools).
    costEstimate.sampleRunCount  how many runs the observation is based on.
    observedCost             avgCredits, medianCredits, maxCredits per unit across
                             all workspaces' runs, or status "unavailable" with
                             typical {lowCredits, highCredits, unit}.
    has_more / next_cursor   the page is bounded; pass --cursor to continue.
    is_truncated             true when the page was cut for size.
```

## plays activity

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays activity [options]

Count Play runs and delivered Monitor findings by day.

Options:
  --time-zone <iana>       Calendar timezone (default: UTC) (default: "UTC")
  --days <count>           Trailing calendar days, 1–45 (default: "30")
  --end-date <yyyy-mm-dd>  Last local calendar day
  --group-by <kind>        kind or trigger_source (default: "kind")
  --json                   Emit exact counts and coverage as JSON
  -h, --help               display help for command
```

## plays pin

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays pin [options] <target>

Pin an org-owned play to the top of play listings.

Options:
  --dry-run   Print the planned change without saving it
  --json      Emit JSON output
  -h, --help  display help for command
```

## plays unpin

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays unpin [options] <target>

Remove an org-owned play from the pinned group.

Options:
  --dry-run   Print the planned change without saving it
  --json      Emit JSON output
  -h, --help  display help for command
```

## plays search

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays search [options] [task]

Deprecated. Use deepline search --type <types>.

Options:
  --all                      Include plays your workspace created
  --compact                  Accepted for compatibility; results are compact
  --categories <categories>  Only tools in these categories, comma-separated
  --limit <count>            Results per page, 1-50
  --offset <count>           Results to skip, for the next page
  --summary-width <chars>    Description characters per result (default 140)
  --json                     Print JSON instead of the readable list
  -h, --help                 display help for command
```

## plays grep

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays grep [options] <query>

Search active org-owned Plays through Convex full-text search.

Options:
  --json      Emit JSON output
  -h, --help  display help for command
```

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Explanation:
  Purpose:
    Full-text search over plays this workspace authored (not prebuilt ones).
  When:
    Finding a saved play by a phrase in its source or description.
  Input:
    A query. --json prints JSON.
  Output (JSON):
    Matching owned plays with the matched fields and terms.
  Cost:
    Free.
```

## plays versions

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays versions [options]

List revisions for a named play.

Options:
  --name <name>  Saved play name
  --json         Emit JSON output
  -h, --help     display help for command
```

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Explanation:
  Purpose:
    List the saved revisions of a workspace play, newest first, and which one
    is live.
  When:
    Before making an older revision live or running a specific revision.
  Input:
    --name <play>. --json forces JSON.
  Output (JSON):
    The play's revisions, each with its revision id and whether it is live.
  Cost:
    Free.
```

## plays save

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays save [options] <file>

Save or update a local Play working draft without publishing it.

Options:
  --expected-artifact <hash>  Require the checked artifact hash
  --dry-run                   Bundle and show the planned draft save without
                              mutation
  --json                      Emit JSON output
  -h, --help                  display help for command
```

## plays deploy

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays deploy [options] [directory]

Deploy every play in a directory as one unit (all go live together, or none).

Options:
  --manifest <file>    Manifest file name in the directory (default:
                       deepline.json)
  --repo <owner/name>  Repository to record on the deployment
  --ref <ref>          Branch or ref to record on the deployment
  --commit <sha>       Commit to record on the deployment
  --json               Emit JSON output
  -h, --help           display help for command
```

## plays deployments

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays deployments [options] [id]

Deployment history for this workspace; pass an id for one deployment and its
plays.

Options:
  --limit <n>  Max rows (default 50)
  --json       Emit JSON output
  -h, --help   display help for command
```

## plays publish

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays publish [options] <target>

Promote a saved play revision or publish a local play file.

Options:
  --latest                    Promote the newest saved revision
  --revision-id <id>          Revision to promote
  --expected-artifact <hash>  Require the local file to produce this checked
                              artifact hash
  --dry-run                   Bundle and show the planned publish without
                              mutation
  --json                      Emit JSON output
  -h, --help                  display help for command
```

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Explanation:
  Purpose:
    Publish a local .play.ts file or promote a saved revision, so run
    <name>, triggers, and deepline.runPlay callers use it. The same operation as
    plays set-live.
  When:
    Once a play run by file path gives the right result. Running a local file
    never publishes it.
  Input:
    A local path ending in .play.ts, or a saved play name with --latest or
    --revision-id <id>. --dry-run bundles and prints the planned artifact
    without publishing. --expected-artifact <hash> refuses to publish when the
    file no longer produces the artifact hash plays check printed.
  Output (JSON):
    success, name, liveVersion, revisionId, artifactHash, and the trigger
    metadata and bindings now live.
  Cost:
    Free. It changes cloud state: every caller of the play name gets the new
    version at once.
  Avoid:
    A cron or webhook trigger cannot report its own failure. After publishing
    a triggered play, check that a failure notifies someone: notifications
    --help.
```

## plays set-live

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays set-live [options] <target>

Promote a saved revision or publish a local play file.

Options:
  --latest                    Promote the newest saved revision
  --revision-id <id>          Revision to promote
  --expected-artifact <hash>  Require the local file to produce this checked
                              artifact hash
  --dry-run                   Bundle and show the planned publish without
                              mutation
  --json                      Emit JSON output
  -h, --help                  display help for command
```

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Explanation:
  Purpose:
    Make one version of a play live, so run <name>, triggers, and
    deepline.runPlay callers use it. A local .play.ts file is bundled, validated,
    saved as a revision, and promoted in one step; a saved play promotes one
    of its existing revisions.
  When:
    After iterating on a local file with run ./file.play.ts, once its
    result is right. Running a local file never publishes it.
  Input:
    A local path ending in .play.ts, or a saved play name with --latest or
    --revision-id <id>. --dry-run bundles and prints the planned artifact
    without publishing. --expected-artifact <hash> refuses to publish when the
    file no longer produces the artifact hash plays check printed.
  Output (JSON):
    success, name, liveVersion, revisionId, artifactHash, previousLiveVersion,
    previousArtifactHash, and the trigger metadata and bindings now live.
  Cost:
    Free. It changes cloud state: every caller of the play name gets the new
    version at once.
  Avoid:
    Do not publish to test a change; run the file by path instead.
    A cron or webhook trigger cannot report its own failure. After publishing
    a triggered play, check that a failure notifies someone: notifications
    --help.
```

## plays delete

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays delete [options] <target>

Move an org-owned play to Trash and stop its triggers.

Options:
  -y, --yes   Confirm deletion
  --dry-run   Show the planned archive without mutating the play
  --json      Emit JSON output
  -h, --help  display help for command
```

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Explanation:
  Purpose:
    Move a workspace play to Trash and stop its triggers. Its revisions and
    run history are kept, so it can be restored.
  When:
    When the user asks to remove a play. Prebuilt plays cannot be deleted.
  Input:
    The play name. --yes confirms; --dry-run shows the planned change.
  Output (JSON):
    The deleted play and the triggers that were stopped.
  Cost:
    Free.
```

## plays restore

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays restore [options] <target>

Restore an org-owned play from Trash.

Options:
  --json      Emit JSON output
  -h, --help  display help for command
```

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Explanation:
  Purpose:
    Restore a play from Trash. The saved play is enabled again and its trigger
    bindings are recreated.
  When:
    After a play was deleted by mistake.
  Input:
    The play name. --json forces JSON.
  Output (JSON):
    The restored play.
  Cost:
    Free.
```

## plays share

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays share [options] [command]

Manage a play's public, unlisted share page (advanced — exposes play code).

Options:
  -h, --help                   display help for command

Commands:
  status [options] <play>      Show a play's share-page status and revision
                               picker.
  publish [options] <play>     Publish/repoint a PUBLIC page to a revision.
                               Advanced; not recommended unless explicitly
                               requested and risks confirmed.
  update [options] <play>      Update share-page settings without moving the
                               pointer.
  regenerate [options] <play>  Regenerate the public page's LLM copy for a
                               revision.
  unpublish [options] <play>   Unshare: permanently delete the public page
                               (frees it). Requires --yes.
  help [command]               display help for command
```

## plays share status

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays share status [options] <play>

Show a play's share-page status and revision picker.

Options:
  --json      Emit JSON output
  -h, --help  display help for command
```

## plays share publish

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays share publish [options] <play>

Publish/repoint a PUBLIC page to a revision. Advanced; not recommended unless
explicitly requested and risks confirmed.

Options:
  --latest            Publish the newest revision (default).
  --version <n>       Publish a specific version number.
  --revision-id <id>  Publish a specific revision id.
  --seo <mode>        SEO indexing: index | noindex.
  --show-cost         Show average Deepline credit cost on the page.
  --show-latency      Show average latency on the page.
  --no-run-check      Skip the "must have a completed run" gate.
  -y, --yes           Confirm public exposure of the play code/structure
                      (required).
  --dry-run           Show the planned publish without writing.
  --json              Emit JSON output
  -h, --help          display help for command
```

## plays share update

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays share update [options] <play>

Update share-page settings without moving the pointer.

Options:
  --seo <mode>    SEO indexing: index | noindex.
  --show-cost     Show average Deepline credit cost.
  --hide-cost     Hide average Deepline credit cost.
  --show-latency  Show average latency.
  --hide-latency  Hide average latency.
  --json          Emit JSON output
  -h, --help      display help for command
```

## plays share regenerate

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays share regenerate [options] <play>

Regenerate the public page's LLM copy for a revision.

Options:
  --version <n>       Regenerate a specific version number.
  --revision-id <id>  Regenerate a specific revision id.
  --json              Emit JSON output
  -h, --help          display help for command
```

## plays share unpublish

```text theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
Usage: deepline plays share unpublish [options] <play>

Unshare: permanently delete the public page (frees it). Requires --yes.

Options:
  -y, --yes   Confirm taking the public page down (required).
  --json      Emit JSON output
  -h, --help  display help for command
```


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.